------- 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+"個");
}
}
