标签：
------- android培训、java培训、期待与您交流！ ----------
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的相互转换
Stirng s;
1.StringBuffer sb = new StringBuffer (s);
2.StringBuffer sb = new StringBuffer (); sb.append(s);
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+"个"); } }
标签：
原文地址：http://www.cnblogs.com/zhy7201/p/4525029.html
