13.01 StringBuffer的概述
StringBuffer类概述:线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
StringBuffer和String的区别:StringBuffer长度和内容可变，String不可变。使用StringBuffer做字符串的拼接不会浪费太多资源
13.02 StringBuffer类的构造方法
1. public StringBuffer():
构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
2. public StringBuffer(int capacity):
构造一个不带字符，但具有指定初始容量的字符串缓冲区
3. public StringBuffer(String str):
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16加上字符串参数的长度
例:
1 StringBuffer sb1 = new StringBuffer();
2 System.out.println(sb1.capacity());//16
3 System.out.println(sb1.length());//0
4
5 StringBuffer sb2 = new StringBuffer("hello");
6 System.out.println(sb2.capacity());//21
7 System.out.println(sb2.length());//5
13.03 StringBuffer的添加功能
1. public StringBuffer append(String str):
将指定的字符串追加到此字符序列
2. public StringBuffer insert(int offset,String str):
将字符串插入此字符序列中
13.04 StringBuffer的删除功能
1. public StringBuffer deleteCharAt(int index):
移除此序列指定位置的 char。此序列将缩短一个 char
2. public StringBuffer delete(int start,int end):
移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符，如果不存在这种字符，则一直到序列尾部。如果 start 等于 end，则不发生任何更改
13.05 StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str):
使用给定 String 中的字符替换此序列的子字符串中的字符
13.06 StringBuffer的反转功能
public StringBuffer reverse():将此字符序列用其反转形式取代
13.07 StringBuffer的截取功能
1. public String substring(int start)
返回一个新的 String，它包含此字符序列当前所包含的字符子序列
2. public String substring(int start,int end)
返回一个新的 String，它包含此序列当前所包含的字符子序列。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符
13.08 StringBuffer和String的相互转换
String和StringBuffer的相互转换
- String →StringBuffer
Stirng s;
1.StringBuffer sb = new StringBuffer (s);
2.StringBuffer sb = new StringBuffer (); sb.append(s);
- StringBuffer →String
1.String s = new String(sb);
2.String s = sb.toString();
13.09 把数组拼接成指定格式的字符串案例
1 public class Practice
2 {
3 public static void main(String[] args)
4 {
5 //定义数组
6 int[] arr = {23,52,12,63,25};
7 String s = arrToString(arr);
8 System.out.println(s);
9 }
10 public static String arrToString(int[] arr)
11 {
12 StringBuffer sb = new StringBuffer("[");
13 for (int i = 0; i < arr.length; i++)
14 {
15 if(i == arr.length -1)
16 {
17 sb.append(arr[i]);
18 }
19 else
20 {
21 sb.append(arr[i]).append(", ");
22 }
23 }
24 sb.append("]");
25 return sb.toString();
26 }
27 }
13.10 字符串反转功能案例
1 import java.util.Scanner;
2
3 public class Practice
4 {
5 public static void main(String[] args)
6 {
7 Scanner sc = new Scanner(System.in);
8 System.out.println("请输入数据:");
9 String str = sc.nextLine();
10 String s = myReverse(str);
11 System.out.println(s);
12 }
13 public static String myReverse(String s)
14 {
15 return new StringBuffer(s).reverse().toString();
16 }
17 }
13.11 判断一个字符串是否对称案例
判断一个字符串是否是对称字符串，例"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
1 public class Practice
2 {
3 public static void main(String[] args)
4 {
5 String s = "abcba";
6 System.out.println(isSame2(s));
7 }
8 //方式1
9 public static String isSame(String s)
10 {
11 // 把字符串转成字符数组
12 char[] chs = s.toCharArray();
13 for (int start = 0, end = chs.length - 1; start <= end; start++, end--)
14 {
15 if (chs[start] != chs[end])
16 {
17 return "不对称";
18 }
19 }
20 return "对称";
21 }
22 //方式2
23 public static boolean isSame2(String s)
24 {
25 return new StringBuffer(s).reverse().toString().equals(s);
26 }
27 }
13.12 StringBuffer的两个面试题
第1题:String,StringBuffer,StringBuilder的区别
1.String是内容不可变的，而StringBuffer和StringBuilder都是内容可变的
2.StringBuffer是同步的，数据安全，效率低
StringBuilder是不同步的，数据不安全，效率高
第2题:StringBuffer和数组的区别
StringBuffer和数组都是可以装数据的容器
StringBuffer可以存储任意类型的数据，但最终是一个字符串数据
数组只能存储同一种数据类型的数据
13.13 String和StringBuffer分别作为参数传递
例:
1 public class Practice
2 {
3 public static void main(String[] args)
4 {
5 String s1 = "hello";
6 String s2 = "world";
7 System.out.println(s1 + "---" + s2);
8 change(s1, s2);
9 System.out.println(s1 + "---" + s2);
10
11 StringBuffer sb1 = new StringBuffer("hello");
12 StringBuffer sb2 = new StringBuffer("world");
13 System.out.println(sb1 + "---" + sb2);
14 change(sb1, sb2);
15 System.out.println(sb1 + "---" + sb2);
16 }
17 public static void change(StringBuffer sb1, StringBuffer sb2)
18 {
19 sb1 = sb2;
20 sb2.append(sb1);
21 }
22
23 public static void change(String s1, String s2)
24 {
25 s1 = s2;
26 s2 = s1 + s2;
27 }
28 }
运行结果:
hello---world hello---world hello---world hello---worldworld
注意:String作为参数传递，效果与基本类型作为参数传递一样
13.14 数组高级冒泡排序原理图解
冒泡排序原理:将数组0下标的数与1下标的数比较，如果1下标的数小于0下标的数则交换位置，然后将1下标的数与2下标的数比较，如果1下标的数大于2下标的数则交换位置，反之就不交换位置，直到比较结束最后一个下标存放的就是数组中最大的数，第一轮比较结束。然后再从0下标与1下标的数比较，此时最后一个数不需要参与比较，重复以上步骤直到结束。(从小到大排序)
13.15 数组高级冒泡排序代码实现
1 public class Practice
2 {
3 /**
4 * 冒泡排序
5 * @param args
6 */
7 public static void main(String[] args)
8 {
9 int[] arr = {2,1,55,-12,45,25,-64};
10 System.out.println("排序前:");
11 print(arr);
12 bubbleSort(arr);
13 System.out.println("排序后:");
14 print(arr);
15 }
16 public static void bubbleSort(int[] arr)
17 {
18 for (int i = 0; i < arr.length-1; i++)
19 {
20 //-1是为了避免角标越界
21 //-i是为了让内循环参与比较的次数随着外循环的增加而递减
22 for (int j = 0; j < arr.length-1-i; j++)
23 {
24 if(arr[j]>arr[j+1])
25 {
26 int temp = arr[j];
27 arr[j] = arr[j+1];
28 arr[j+1] = temp;
29 }
30 }
31 }
32 }
33 //遍历数组
34 public static void print(int[] arr)
35 {
36 for (int i = 0; i < arr.length; i++)
37 {
38 System.out.print(arr[i]+" ");
39 }
40 System.out.println();
41 }
42 }
运行结果:
排序前: 2 1 55 -12 45 25 -64 排序后: -64 -12 1 2 25 45 55
13.16 数组高级选择排序原理图解
选择排序原理:将数组内0下标的元素依次与后面的元素比较，如果1下标之后的元素小于0下标的元素就将该元素与0下标的元素交换位置，比较完成后0下标的元素存放的就是最小值，第一轮比较结束。然后从1下标开始依次与后面的元素比较，比较完成后1下标存放的就是第二小的数，依次类推直到排序结束。(由小到大排序)
13.17 数组高级选择排序代码实现
1 public class Practice
2 {
3 /**
4 * 选择排序
5 * @param args
6 */
7 public static void main(String[] args)
8 {
9 int[] arr = {2,15,23,12,76,73,18,29};
10 System.out.println("排序前:");
11 print(arr);
12 selectSort(arr);
13 System.out.println("排序后:");
14 print(arr);
15 }
16 public static void selectSort(int[] arr)
17 {
18 for (int i = 0; i < arr.length-1; i++)
19 {
20 for (int j = i+1; j < arr.length; j++)
21 {
22 if(arr[i]>arr[j])
23 {
24 int temp = arr[i];
25 arr[i] = arr[j];
26 arr[j] = temp;
27 }
28 }
29 }
30 }
31 //遍历数组
32 public static void print(int[] arr)
33 {
34 for (int i = 0; i < arr.length; i++)
35 {
36 System.out.print(arr[i]+" ");
37 }
38 System.out.println();
39 }
40 }
运行结果:
排序前: 2 15 23 12 76 73 18 29 排序后: 2 12 15 18 23 29 73 76
13.18 把字符串中的字符进行排序案例
1 public class Practice
2 {
3 /**
4 * @param args
5 */
6 public static void main(String[] args)
7 {
8 String s = "dacgebf";
9 char[] ch = s.toCharArray();
10 selectSort(ch);
11 System.out.println(new String(ch));
12 }
13 public static void selectSort(char[] ch)
14 {
15 for (int i = 0; i < ch.length-1; i++)
16 {
17 for (int j = i+1; j < ch.length; j++)
18 {
19 if(ch[i] > ch[j])
20 {
21 char temp = ch[i];
22 ch[i] = ch[j];
23 ch[j] = temp;
24 }
25 }
26 }
27 }
28 }
13.19 数组高级二分查找原理图解
二分查找的前提数组元素必须有序
13.20 数组高级二分查找代码实现
1 public class Practice
2 {
3 /**
4 * 二分查找
5 * @param args
6 */
7 public static void main(String[] args)
8 {
9 int[] arr = {11,15,23,28,35,39,48,49,58};
10 int index = binarySearch(arr, 28);
11 System.out.println(index);
12 }
13 public static int binarySearch(int[] arr,int key)
14 {
15 int min = 0;
16 int max = arr.length-1;
17 int mid = (min+max)/2;
18 while(arr[mid]!=key)
19 {
20 if(arr[mid]>key)
21 max = mid-1;
22 if(arr[mid]<key)
23 min = mid+1;
24 if(min>max)
25 return -1;
26 mid = (min+max)/2;
27 }
28 return mid;
29 }
30 }
13.21 二分查找使用的注意事项
如果数组元素是无序的，这种情况下的查找不能使用二分查找，因为使用二分查找元素必须有序，如果先排序再使用二分查找，排序的时候已经改变了最原始的元素索引。
13.22 Arrays工具类的概述和使用
此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
成员方法:
1. public static String toString(int[] a):
返回指定数组内容的字符串表示形式。
2. public static void sort(int[] a):
对指定的 int 型数组按数字升序进行排序。
3. public static int binarySearch(int[] a,int key):
使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
例:
1 //定义一个数组
2 int[] arr = {23,25,65,85,34,82};
3 //数组转字符串
4 System.out.println(Arrays.toString(arr));
5 //数组排序
6 Arrays.sort(arr);
7 System.out.println(Arrays.toString(arr));
8 //二分查找
9 System.out.println(Arrays.binarySearch(arr, 65));
运行结果:
[23, 25, 65, 85, 34, 82] [23, 25, 34, 65, 82, 85] 3
binarySearch方法如果要查找的数在数组中存在，则返回的是该数在数组中的位置
如果不存在则返回的是该数在数组中插入的位置，该数是一个负数，表示要查找的数在数组中不存在
插入位置的计算方法为:例如返回的是-7，则在数组中应该插入的位置是7-1=6
13.23 Arrays工具类的源码解析
13.24 基本类型包装类的引入
为了方便操作基本数据类型值，将基本数据类型封装成对象，在对象中定义了属性和行为，用于描述该对象的类就称为基本数据类型对象包装类，好处在于可以在对象中定义更多的功能方法操作该数据。常用的操作之一:用于基本数据类型与字符串之间的转换。
13.25 Integer的构造方法
Integer类概述:Integer 类在对象中包装了一个基本类型 int 的值
该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法
构造方法:
public Integer(int value):
构造一个新分配的 Integer 对象，它表示指定的 int 值。
public Integer(String s)throws NumberFormatException:
构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
例:
1 int i = 100;
2 Integer i1 = new Integer(i);
3 System.out.println("Integer:"+i1);
4
5 String s = "100";
6 Integer i2 = new Integer(s);
7 System.out.println("Integer:"+i2);
13.26 String和int类型的相互转换
int→String
1.使用字符串的拼接 " "+number
2.使用方法 String.valueOf(int number)(推荐使用)
3.使用Integer做桥梁，int→Integer→String
Integer i = new Integer(number);
String s = i.toString();
4.使用方法 Integer.toString(int number)
String→int
1.使用Integer做桥梁，String→Integer→int
Integer i = new Integer(s);
int ii = i.intValue();
2.使用方法 Integer.parseInt(String s)(推荐使用)
13.27 Integer中进制转换的操作
1. 常用的基本进制转换
a. public static String toBinaryString(int i):
以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
b. public static String toOctalString(int i):
以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。
c. public static String toHexString(int i):
以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
2. 十进制到其他进制
public static String toString(int i,int radix):
返回用第二个参数指定基数表示的第一个参数的字符串表示形式。radix范围从2~36
3. 其他进制到十进制
public static int parseInt(String s,int radix)throws NumberFormatException
使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
13.28 JDK5的新特性自动装箱和拆箱
自动装箱:把基本类型转换为包装类类型
自动拆箱:把包装类类型转换为基本类型
JDK1.5以后，简化了定义方式。
Integer x = new Integer(4);可以直接写成
Integer x = 4;//相当于Integer x = Integer.valueOf(4);自动装箱
x = x + 5;//相当于x = Integer.valueOf(x.intValue() + 5);先自动拆箱，再自动装箱
需要注意:在使用时，Integer x = null;上面的代码就会出现NullPointerException。
13.29 Integer直接赋值的面试题
1.Integer i = 1;i += 1;做了哪些事情
编译时:
Integer i = 1;相当于Integer i = Integer.valueOf(1);
i += 1;相当于i = Integer.valueOf(i.intValue() + 1);
2.看程序写结果
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//false
System.out.println(i1.equals(i2));//true
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//false
System.out.println(i3.equals(i4));//true
Integer i5 = 127;
Integer i6 = 127;
System.out.println(i5 == i6);//true
System.out.println(i5.equals(i6));//true
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);//false
System.out.println(i7.equals(i8));//true
注意:Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据
通过查看源码，我们就知道了，针对-128到127之间的数据，做了一个数据缓冲池，如果，数据是该范围内的，每次并不创建新的空间
13.30 Character的概述
Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。
构造方法:
public Character(char value):
构造一个新分配的 Character 对象，用以表示指定的 char 值。
13.31 Character的常见方法讲解
1. public static boolean isUpperCase(char ch):
确定指定字符是否为大写字母。
2. public static boolean isLowerCase(char ch):
确定指定字符是否为小写字母。
3. public static boolean isDigit(char ch):
确定指定字符是否为数字。
4. public static char toUpperCase(char ch):
使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。
5. public static char toLowerCase(char ch):
使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。
13.32 统计字符串中大写小写以及数字出现的次数案例
public class Practice
{
/**
* @param args
*/
public static void main(String[] args)
{
String s = "SdfgD32sdF65hfg3Sf s3EDf S";
int big = 0,samll = 0,number = 0;
char[] chs = s.toCharArray();
for (int i = 0; i < chs.length; i++)
{
if(Character.isUpperCase(chs[i]))
big++;
else if(Character.isLowerCase(chs[i]))
samll++;
else if(Character.isDigit(chs[i]))
number++;
}
System.out.println("大写字符"+big+"个");
System.out.println("小写字符"+samll+"个");
System.out.println("数字字符"+number+"个");
}
}