13 StringBuffer&陣列排序
阿新 • • 發佈：2018-10-31
13.01_常見物件（StringBuffer類的概述）
- A：StringBuffer類的概述
* 執行緒安全的可變字元序列 - B：StringBuffer與String的區別
* String是一個不可變的字元序列，一旦初始化就不能變
* StringBuffer是一個可變的字元序列
13.02_常用物件（StringBuffer類的構造方法）
- A:StringBuffer類的構造方法
* public StringBuffer():無參構造方法
* public StringBuffer(int capacity):指定容量的字串緩衝區物件
* public StringBuffer(String str):指定字串內容的字串緩衝區物件 - B:StringBuffer類的方法
* public int capacity(): 返回當前容量。理論值（不掌握）
* public int length(): 返回長度（字元數）。實際值
public static void main(String[] args) { StringBuffer sb = new StringBuffer(); System.out.println(sb.length()); //容器中的字元個數,實際值 System.out.println(sb.capacity()); //容器的初始容量,理論值 StringBuffer sb2 = new StringBuffer(10); //指定初始容量 System.out.println(sb2.length()); System.out.println(sb2.capacity()); StringBuffer sb3 = new StringBuffer("heima"); System.out.println(sb3.length()); //實際字元的個數 System.out.println(sb3.capacity()); //字串的length + 初始容量 }
13.03_append()和insert()方法 新增
- A:StringBuffer的新增功能
* public StringBuffer append(String str):
* 可以把任意型別資料新增到字串緩衝區裡面,並返回字串緩衝區本身
* public StringBuffer insert(int offset,String str):
* 在指定位置把任意型別的資料插入到字串緩衝區裡面,並返回字串緩衝區本身
StringBuffer是字串緩衝區,當new的時候是在堆記憶體建立了一個物件,底層是一個長度為16的字元陣列當呼叫新增的方法時,不會再重新建立物件,在不斷向原緩衝區新增字元
public static void main(String[] args) {
//demo1();
StringBuffer sb = new StringBuffer("1234");
sb.insert(3, "heima"); //在指定位置新增元素,如果沒有指定位置的索引就會報索引越界異常
System.out.println(sb);
}
private static void demo1() {
StringBuffer sb = new StringBuffer();
StringBuffer sb2 = sb.append(true);//每次返回的引用雖然不同，但是指向的都是同一個物件
StringBuffer sb3 = sb.append("heima");
StringBuffer sb4 = sb.append(100);
System.out.println(sb.toString()); //StringBuffer類中重寫了toString方法,顯示的是物件中的屬性值
System.out.println(sb2.toString());
System.out.println(sb3.toString());
System.out.println(sb4.toString());
}
13.04_ delete() 刪除
- A:StringBuffer的刪除功能
* public StringBuffer deleteCharAt(int index):
* 刪除指定位置的字元，並返回本身
* public StringBuffer delete(int start,int end):
* 刪除從指定位置開始指定位置結束的內容，並返回本身
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//sb.deleteCharAt(5); //當緩衝區中這個索引上沒有元素的時候就會報StringIndexOutOfBoundsException
sb.append("heima");
//sb.deleteCharAt(4); //根據索引刪除掉索引位置上對應的字元
//sb.delete(0, 2); //刪除的時候是包含頭,不包含尾
//System.out.println(sb);
//sb.delete(0, sb.length()); //清空緩衝區
//System.out.println(sb);
sb = new StringBuffer(); //不要用這種方式清空緩衝區,原來的會變成垃圾,浪費記憶體
System.out.println(sb);
}
13.05_替換和反轉
- A:StringBuffer的替換功能
* public StringBuffer replace(int start,int end,String str):
* 從start開始到end用str替換
* B:StringBuffer的反轉功能
* public StringBuffer reverse():
* 字串反轉
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("heima");
//sb.replace(0, 3, "bai"); //替換
//System.out.println(sb);
sb.reverse();
System.out.println(sb);
}
13.06_擷取
- A:StringBuffer的擷取功能
* public String substring(int start):
* 從指定位置擷取到末尾
* public String substring(int start,int end):
* 擷取從指定位置開始到結束位置，包括開始位置，不包括結束位置- B:注意事項
- 注意:返回值型別不再是StringBuffer本身，而是String
- B:注意事項
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("woaiheima");
//String str = sb.substring(4);
//System.out.println(str);
//System.out.println(sb);
String str3 = sb.substring(4, 7);
System.out.println(str3);
}
13.07_ String 與 StringBuffer的轉換
- A:String – StringBuffer
* a:通過構造方法
* b:通過append()方法 - B:StringBuffer – String
* a:通過構造方法
* b:通過toString()方法
* c:通過subString(0,length)
public static void main(String[] args) {
//demo1();
StringBuffer sb = new StringBuffer("heima");
String s1 = new String(sb); //通過構造將StringBuffer轉換為String
System.out.println(s1);
String s2 = sb.toString(); //通過toString方法將StringBuffer轉換為String
System.out.println(s2);
String s3 = sb.substring(0, sb.length()); //通過擷取子字串將StringBuffer轉換為String
System.out.println(s3);
}
private static void demo1() {
StringBuffer sb1 = new StringBuffer("heima"); //通過構造方法將字串轉換為StringBuffer物件
System.out.println(sb1);
StringBuffer sb2 = new StringBuffer();
sb2.append("heima"); //通過append方法將字串轉換為StringBuffer物件
System.out.println(sb2);
}
13.08_練習
/**
* * 需求：把陣列中的資料按照指定個格式拼接成一個字串
*
舉例：
int[] arr = {1,2,3};
輸出結果：
"[1, 2, 3]"
用StringBuffer的功能實現
*/
public static void main(String[] args) {
int[] arr = {1,2,3};
System.out.println(arrayToString(arr));
}
/*
* 將陣列轉換為字串
* 1,返回值型別String
* 2,引數列表int[]
*
* arrayToString 將陣列轉換為字串
* array2String 2與to的發音一樣就用2替換了to,後來演變成了一種書寫習慣
* dom4j domForJ
*/
public static String arrayToString(int[] arr) {
StringBuffer sb = new StringBuffer(); //建立字串緩衝區物件
sb.append("["); //將[新增到緩衝區
//{1,2,3}
for (int i = 0; i < arr.length; i++) { //遍歷陣列
//sb.append(arr[i] + ", "); //這樣做沒有]
if(i == arr.length - 1) {
sb.append(arr[i]).append("]"); //[1, 2, 3]
}else {
sb.append(arr[i]).append(", "); //[1, 2,
}
}
return sb.toString();
}
}
13.09_練習 字串反轉
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); //建立鍵盤錄入物件
String line = sc.nextLine(); //將鍵盤錄入的字串儲存在line中
System.out.println(revString(line));
}
/*
* 將字串反轉
* 1,返回值型別String
* 2,引數列表String line
*/
public static String revString(String line) {
StringBuffer sb = new StringBuffer(line); //將字串轉換為StringBuffer物件
sb.reverse(); //將緩衝區的內容反轉
return sb.toString();
}
13.10_StringBuffer和StringBuilder區別
- 面試題：
-
StringBuffer和StringBuilder的區別
- StringBuffer是jdk1.0版本，是執行緒安全的，效率低
- StringBuilder是jdk1.5版本，是執行緒不安全的，效率高
-
StringBuffer，StringBuilder，String區別
- String是一個不可變的字元序列
- StringBuffer，StringBuilder是可變的字元序列
-
13.11_String和StringBuffer做引數時的區別
- A:形式引數問題
* String作為引數傳遞
* StringBuffer作為引數傳遞 - B:案例演示
* String和StringBuffer分別作為引數傳遞問題
public static void main(String[] args) {
int a=10;
String s = "heima";
System.out.println(s);
change(s,a); //此方法彈棧之後“heimaitcast”就變成了垃圾
System.out.println(s);//故此處列印的還是最開始的 "heima"物件
System.out.println(a);//10 基本資料型別的值傳遞,不改變其值
System.out.println("---------------------");
StringBuffer sb = new StringBuffer();
sb.append("heima");
System.out.println(sb);
change(sb);
System.out.println(sb);//引用資料型別的值傳遞,改變其值
}
public static void change(StringBuffer sb) {
sb.append("itcast");
}
public static void change(String s,int a) {
s += "itcast";
a=a+10;
}
基本資料型別的值傳遞,不改變其值(為啥)
引用資料型別的值傳遞,改變其值
String類雖然是引用資料型別,但是他當作引數傳遞時和基本資料型別是一樣的
13.12_陣列高階氣泡排序原理圖解（面試）
- 氣泡排序：輕的上浮，沉的下降
- 陣列元素：｛24，69，80，57，13｝
- 兩個相鄰位置比較，如果前面的元素比後面的元素大就換位置
- 第一次：arr[0]與arr[1],arr[1]與arr[2],arr[2]與arr[3],arr[3]與arr[4]比較四次，最大的數移到最後的位置
- 第二次：arr[0]與arr[1],arr[1]與arr[2],arr[2]與arr[3]比較三次
- 第三次：arr[0]與arr[1],arr[1]與arr[2]比較二次
- 第四次：arr[0]與arr[1]比較一次
13.13_陣列高階氣泡排序程式碼實現（面試）
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13};
bubbleSort(arr);
print(arr);
}
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) { //外迴圈只需要比較arr.length-1次就可以了
for (int j = 0; j < arr.length - 1 - i; j++) { //-1為了防止索引越界,-i為了提高效率
if(arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j+1] = temp;
}
}
}
}
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
13.14_陣列高階選擇排序原理圖解（面試）
- 選擇排序：用一個索引位置上的元素，依次與其他索引位置上的元素比較，符合小的在前大的在後就不變位置，如果有一對比較不符合就將這兩個元素交換位置
- 第一次比較，找到最小的數且放在了第一個位置，該數不參與第二次比較
- 以此類推
- 第一次:arr[0]分別與arr[1-4]比較,比較4次
- 第二次:arr[1]分別與arr[2-4]比較,比較3次
- 第三次:arr[2]分別與arr[3-4]比較,比較2次
- 第四次:arr[3]與arr[4]比較,比較1次
13.15_陣列高階選擇排序程式碼實現（面試）
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) { //只需要比較arr.length-1次
for (int j = i + 1; j < arr.length; j++) {
if(arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
13.16_陣列高階二分查詢原理圖解（面試）
- 二分查詢：查詢元素對應的索引
- 前提：陣列是有序的
13.17_陣列高階二分查詢程式碼實現及注意事項（面試）
public static int getIndex(int[] arr, int value) {
int min = 0;
int max = arr.length - 1;
int mid = (min + max) / 2;
while(arr[mid] != value) { //當中間值不等於要找的值,就開始迴圈查詢
if(arr[mid] < value) { //當中間值小於了要找的值
min = mid + 1; //最小的索引改變
}else if (arr[mid] > value){ //當中間值大於了要找的值
max = mid - 1; //最大的索引改變
}
mid = (min + max) / 2; //無論最大還是最小改變,中間索引都會隨之改變
if(min > max) { //如果最小索引大於了最大索引,就沒有查詢的可能性了
return -1; //返回-1
}
}
return mid; //返回索引
}
}
13.18_Arrays類的概述和使用方法
- A:Arrays類的概述
* 針對陣列進行操作的工具類
* 提供了排序、查詢等功能 - B:成員方法
* public static String toString(int[] a)
* public static void sort(int [] a)
* public static int binarySearch(int [] a,int key)
public static void main(String[] args) {
int[] arr = {33,22,11,44,66,55};
System.out.println(Arrays.toString(arr)); //陣列轉字串
Arrays.sort(arr); //排序
System.out.println(Arrays.toString(arr));
int[] arr2 = {11,22,33,44,55,66};//二分查詢法
System.out.println(Arrays.binarySearch(arr2, 22));
System.out.println(Arrays.binarySearch(arr2, 66));
System.out.println(Arrays.binarySearch(arr2, 9)); //-插入點-1
}
13.19_基本資料型別包裝類的概述
- A:為什麼會有基本型別包裝類
* 將基本資料型別封裝成物件的好處在於可以在物件中定義更多的功能方法操作該資料。 - B:常用操作
* 常用的操作之一：用於基本資料型別與字串之間的轉換。 - C:基本型別和包裝類的對應
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
13.20_Integer類的概述和構造方法
-
A:Integer類概述
* 通過JDK提供的API，檢視Integer類的說明* Integer 類在物件中包裝了一個基本型別 int 的值, * 該類提供了多個方法，能在 int 型別和 String 型別之間互相轉換， * 還提供了處理 int 型別時非常有用的其他一些常量和方法 -
B:構造方法
* public Integer(int value)
* public Integer(String s) -
C:案例演示
* 使用構造方法建立物件
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
Integer i1 = new Integer(100);//將基本資料型別轉換成引用資料型別可以方便呼叫類中的方法，
System.out.println(i1);
//Integer i2 = new Integer("abc"); //java.lang.NumberFormatException數字格式異常
//System.out.println(i2); //因為abc不是數字字串,所以轉換會報錯
Integer i3 = new Integer("100");
System.out.println(i3);
}
13.21_String和int型別的互相轉換
-
A:int – String四種方法
* a:和""進行拼接（推薦）
* b:public static String valueOf(int i) //把任意型別轉換成字串（推薦）
* c:int – Integer – String(Integer類的toString方法()) int型別轉換成字串
* d:public static String toString(int i)(Integer類的靜態方法) -
B:String – int（兩種方法）
* a:String – Integer – int
* b:public static int parseInt(String s)基本資料型別包裝類有八種,其中七種都有parseXxx的方法,可以將這七種的字串表現形式轉換成基本資料型別
private static void demo1() {
//int ----> String int轉換成String
int i = 100;
String s1 = i + ""; //**推薦用** 1
String s2 = String.valueOf(i); //**推薦用** 2
Integer i2 = new Integer(i); //3
String s3 = i2.toString(); //4
String s4 = Integer.toString(i);
System.out.println(s1);
//String----> int String 轉換int
String s = "200";
Integer i3 = new Integer(s);
int i4 = i3.intValue(); //將Integer轉換成了int數 1
int i5 = Integer.parseInt(s); //將String轉換為int,**推薦**用這種 2
}
String s1 = "true";
boolean b = Boolean.parseBoolean(s1);
System.out.println(b);
//String s2 = "abc";
//char c = Character.p //char的包裝類Character中沒有parseXxx的方法
//字串到字元的轉換通過toCharArray()就可以把字串轉換為字元陣列
13.22_自動裝箱和自動拆箱
-
A:JDK5的新特性
* 自動裝箱：把基本型別轉換為包裝類型別
* 自動拆箱：把包裝類型別轉換為基本型別 -
B:案例演示
* JDK5的新特性自動裝箱和拆箱* Integer ii = 100; * ii += 200; -
C:注意事項
* 在使用時，Integer x = null;程式碼就會出現NullPointerException。
* 建議先判斷是否為null，然後再使用。
public static void main(String[] args) {
// int x = 100;
// Integer i1 = new Integer(x); //將基本資料型別包裝成物件,裝箱
//
// int y = i1.intValue(); //將物件轉換為基本資料型別,拆箱
Integer i2 = 100; //自動裝箱,把基本資料型別轉換成物件
int z = i2 + 200; //自動拆箱,把物件轉換為基本資料型別
System.out.println(z);
Integer i3 = null;
int a = i3 + 100; //底層用i3呼叫intValue,但是i3是null,null呼叫方法就會出現
System.out.println(a); //空指標異常java.lang.NullPointerException
}
13.23_自動裝箱面試題
public static void main(String[] args) {
Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
System.out.println(i1 == i2); //false
System.out.println(i1.equals(i2)); //true
System.out.println("-----------");
Integer i3 = new Integer(197);
Integer i4 = new Integer(197);
System.out.println(i3 == i4); //false
System.out.println(i3.equals(i4)); //true
System.out.println("-----------");
Integer i5 = 127;
Integer i6 = 127;
System.out.println(i5 == i6); //true
System.out.println(i5.equals(i6)); //true
System.out.println("-----------");
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);
System.out.println(i7.equals(i8)); //true
/*
* -128到127是byte的取值範圍,如果在這個取值範圍內,自動裝箱就不會新建立物件,而是從常量池中獲取
* 如果超過了byte取值範圍就會再新建立物件
*
* public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high) //i>= -128 && i <= 127
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
*/
}