13.01 StringBuffer的概述
13.02 StringBuffer类的构造方法
13.03 StringBuffer的添加功能
13.04 StringBuffer的删除功能
13.05 StringBuffer的替换功能
13.06 StringBuffer的反转功能
13.07 StringBuffer的截取功能
13.08 StringBuffer和String的相互转换
13.09 把数组拼接成指定格式的字符串案例
13.10 字符串反转功能案例
13.11 判断一个字符串是否对称案例
13.12 StringBuffer的两个面试题
13.13 String和StringBuffer分别作为参数传递
13.14 数组高级冒泡排序原理图解
13.15 数组高级冒泡排序代码实现
13.16 数组高级选择排序原理图解
13.17 数组高级选择排序代码实现
13.18 把字符串中的字符进行排序案例
13.19 数组高级二分查找原理图解
13.20 数组高级二分查找代码实现
13.21 二分查找使用的注意事项
13.22 Arrays工具类的概述和使用
13.23 Arrays工具类的源码解析
13.24 基本类型包装类的引入
13.25 Integer的构造方法
13.26 String和int类型的相互转换
13.27 Integer中进制转换的操作
13.28 JDK5的新特性自动装箱和拆箱
13.29 Integer直接赋值的面试题
13.30 Character的概述
13.31 Character的常见方法讲解
13.32 统计字符串中大写小写以及数字出现的次数案例
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+"个");
}
}
118
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
