Day06【API、String、String Builder】上課

1.API講解(掌握)

1.概念介紹

英文全稱：application programming interface 應用程序接口。就是幫助文檔。

我們重點去學習如何查閱API.

2.如何使用API

使用步驟：

1.打開api

5.進入到要查找的類或者接口界面之後查看裏面的內容：

• ​ 看包，看屬於哪個包

注意：在java中只有java.lang包下的內容不用導包。

• 看類(是否是抽象的，是否能被繼承。。) 繼承和實現關係

• 看構造方法：是否可以創建對象

• 看方法：這是重點

• 看豎線左邊的內容：是方法返回值類型和修飾符。
• 豎線右邊的是方法名和參數列表
• 看方法的簡單說明
• 可以點擊方法名進一步查看方法詳細信息

2.String類(必須掌握)

1.介紹

常量：

整數  byte short int long
小數  float double
字符  char
布爾  boolean
字符串 String類，屬於引用數據類型
null 給引用數據類型初始化值的

String類表示java中的字符串常量數據類型，就是在java中只要使用雙引號表示的常量都是使用String類描述，都是String類的對象。

舉例：String s = “abc”;

• String類屬於java.lang包，不用導包

• 看類的描述：String類表示java中的字符串常量數據類型，就是在java中只要使用雙引號表示的常量都是使用String類描述，都是String類的對象。

• 看構造方法：是否可以創建對象

• 看方法：使用方法完成功能

2.構造方法

代碼演示：

package com.itheima.sh.string_con_01;


/*
    String類的構造方法：
        1.String() 就是通過無參構造方法創建String類的對象，但是沒有任何內容就是空字符串
        2.String(String original) 根據字符串來創建一個字符串對象
        3.String(char[] value) 通過字符數組來創建字符串對象
        4.String(byte[] bytes) 通過字節數組來構造新的字符串對象
        5.String(byte[] bytes, int offset, int length) 通過字節數組一部分來構造新的字符串對象
 */
public class StringConsDemo01 {
    public static void main(String[] args) {
        //1.String() 就是通過無參構造方法創建String類的對象，但是沒有任何內容就是空字符串
        //創建String對象
        //s裏面保存的確實是堆內存的地址值，但是輸出的卻不是，原因是和輸出語句有關，主要是底層調用了toString方法
        //大概過兩天講解
//        String s = new String();//相當於String s = "";
//        System.out.println(s);//輸出s表示沒有任何字符串，就是空字符串
        // 3.String(char[] value) 通過字符數組來創建字符串對象
        //定義字符數數組
//        char[] ch = {'a','您','9'};
//        //通過構造方法將上述字符數組轉換爲字符串
//        String s = new String(ch);
//        //輸出s
//        System.out.println("s = " + s);//"a您9"

        // 4.String(byte[] bytes) 通過字節數組來構造新的字符串對象
        //定義字節數組
        byte[] buf = {65, 66, 97, 98};
//        //創建字符串對象將字節數組轉換爲字符串對象
//        String s = new String(buf);
//        //ABab
//        System.out.println("s = " + s);
        /*
            5.String(byte[] bytes, int offset, int length) 通過字節數組一部分來構造新的字符串對象
                參數：
                    bytes - 字節數組
                    offset - 要解碼的第一個 byte 的索引
                    length - 要解碼的 byte 數
         */
        //需求：將上述字節數組中的66 97轉換爲字符串
        //buf 表示字節數組   1 表示66數據的索引值  2 轉換的字節個數
        String s = new String(buf, 1, 2);
        System.out.println("s = " + s);//Ba
    }
}

小結：

1.那麼多構造方法，主要的作用就是將字節和字符數據轉換爲字符串

3.字符串注意事項

1.使用new調用構造方法創建和直接將字符串常量賦值給變量創建對象的區別

 public static void main(String[] args) {
        //1.使用new調用構造方法創建和直接將字符串常量賦值給變量創建對象的區別
        //String(String original)
        String s = new String("abc");
        String s1 = "abc";
        System.out.println("s = " + s);//s = abc
        System.out.println("s1 = " + s1);//s1 = abc
        //比較s和s1
        System.out.println(s == s1);//false 這裏比較的是s和s1的地址值，不是比較表示的內容
    }

2.字符串在創建之後不能被更改

 //2.字符串在創建之後不能被更改
        String s = "abc";
        System.out.println("s = " + s);
        s = "d" + s;
        System.out.println("s = " + s);

3.多個字符串引用變量名共享字符串常量池中的同一個字符串

      //3.多個字符串引用變量名共享字符串常量池中的同一個字符串
        String s = "abc";
        String s1 = "abc";
        //這裏比較的是地址值
        System.out.println(s == s1);//true

4.方法介紹(必須掌握)

1.判斷功能的方法

• public boolean equals (Object anObject) ：將此字符串與指定對象進行比較。

• public boolean equalsIgnoreCase (String anotherString) ：將此字符串與指定對象進行比較，忽略大小寫。

• public boolean contains (CharSequence s)：判斷參數字符串在當前字符串中是否存在(區分大小寫)。存在，返回true，否則，返回false。

• public boolean endsWith(String suffix)：測試此字符串是否以指定的後綴結尾(區分大小寫)。

• public boolean startsWith(String prefix)：測試此字符串是否以指定的前綴開始(區分大小寫)

package com.itheima.sh.string_method_03;
/*
    1.public boolean equals (Object anObject)  ：將此字符串與指定對象進行比較。
        參數：可以傳遞Object的子類String的對象  調用者需要一個字符串對象，那麼這個方法就是比較兩個字符串是否相等
            相等：返回true
            不相等：返回false
        說明：
            1.在開發中只要比較引用數據類型就使用類中的equals方法來比較內容，不要使用==,比較的是引用類型的地址值。
                沒有意義
            2.==：一般是在比較基本數據類型時使用
    2. public boolean equalsIgnoreCase (String anotherString) ` ：將此字符串與指定對象進行比較，忽略大小寫。
    3.public boolean contains (CharSequence s)`：判斷參數字符串在當前字符串中是否存在(區分大小寫)。存在，返回true，否則，返回false。
        參數：CharSequence是String類的父接口，我們可以傳遞子類String的對象
    4.public boolean endsWith(String suffix)`：測試此字符串是否以指定的後綴結尾(區分大小寫)。
    5.public boolean startsWith(String prefix)`：測試此字符串是否以指定的前綴開始(區分大小寫)
 */
public class MethodDemo01 {
    public static void main(String[] args) {
        // 1.public boolean equals (Object anObject)  ：將此字符串與指定對象進行比較。
       /* String s = new String("abc");
        String s1 = "abc";
        //這裏比較的是地址值
        System.out.println(s == s1);//false
        //使用equals方法比較
        //這裏比較的是s和s1表示的內容
        boolean boo = s.equals(s1);
        System.out.println("boo = " + boo);//true*/
       //2. public boolean equalsIgnoreCase (String anotherString) ` ：將此字符串與指定對象進行比較，忽略大小寫。
        String s = "hello";
        String s1 = "Hello";
        //使用equals比較內容
       /* boolean boo = s.equals(s1);
        System.out.println("boo = " + boo);//false
        //使用equalsIgnoreCase忽略大小寫比較
        boolean boo2 = s.equalsIgnoreCase(s1);
        System.out.println("boo2 = " + boo2);//true*/
       //3.public boolean contains (CharSequence s)`：判斷參數字符串在當前字符串中是否存在(區分大小寫)。存在，返回true，否則，返回false。
//        boolean boo3 = s.contains("lo");
//        System.out.println("boo3 = " + boo3);//true
        //4.public boolean endsWith(String suffix)`：測試此字符串是否以指定的後綴結尾(區分大小寫)。
        //需求：判斷字符串s是否以o結尾
//        System.out.println(s.endsWith("oo"));//false

        //5.public boolean startsWith(String prefix)`：測試此字符串是否以指定的前綴開始(區分大小寫)
        //需求：判斷字符串s是否以h開始
        System.out.println(s.startsWith("H"));//false
    }
}

小結：

1.判斷方法，方法返回值都是布爾類型。

2.以後只要比較基本數據類型就使用==,引用數據類型使用equals

2.獲取功能的方法

• public int length () ：返回此字符串的長度。
• public String concat (String str) ：將指定的字符串連接到該字符串的末尾。 建議使用+
• public char charAt (int index) ：返回指定索引處的 char值。
• public int indexOf (String str) ：返回指定子字符串第一次出現在該字符串內的索引。
• public int lastIndexOf(String str) ：返回指定子字符串最後一次出現的字符串中的索引。 如果不包含，則返回-1。
• public String substring (int beginIndex) ：返回一個子字符串，從beginIndex開始截取字符串到字符串結尾。
• public String substring (int beginIndex, int endIndex) ：返回一個子字符串，從beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。包頭不包尾

代碼演示：

package com.itheima.sh.string_method_03;
/*
    1.public int length () ` ：返回此字符串的長度。
    2.public String concat (String str)` ：將指定的字符串連接到該字符串的末尾。 就是拼接 和+功能一樣
    3. public char charAt (int index) ` ：返回指定索引處的 char值。
        參數;index表示索引從0開始 返回值：是根據索引獲取的字符
    4.public int indexOf (String str) ` ：返回指定子字符串第一次出現在該字符串內的索引。
            參數：指定的字符串  返回值：從前向後查找參數的字符串在此字符串第一次出現的索引，如果沒有返回-1
    5.public int lastIndexOf(String str)` ：返回指定子字符串最後一次出現的字符串中的索引。 如果不包含，則返回-1。
    6.public String substring (int beginIndex) ` ：返回一個子字符串，從beginIndex開始截取字符串到字符串結尾。
        參數：
            beginIndex ：表示要截取的字符串開始的索引(包含索引對應的字符)
    7.public String substring (int beginIndex, int endIndex) ` ：
            返回一個子字符串，從beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。**包頭不包尾**
            參數：
               beginIndex：表示要截取的字符串開始的索引(包含索引對應的字符)
               endIndex： 截取的字符串結束的索引(不包含該索引對應的字符)
 */
public class MethodDemo02 {
    public static void main(String[] args) {
        //1.public int length () ` ：返回此字符串的長度。
//        String s = "itcacast";
//        int length = s.length();
//        System.out.println("length = " + length);//length = 6
        //  2.public String concat (String str)` ：將指定的字符串連接到該字符串的末尾。 就是拼接 和+功能一樣
//        String s1 = s.concat("heima");//等同於 s+"heima
//        System.out.println("s1 = " + s1);//itcastheima
        /*
            3. public char charAt (int index) ` ：返回指定索引處的 char值。
                參數;index表示索引從0開始 返回值：是根據索引獲取的字符
         */
//        char c1 = s.charAt(2);
//        System.out.println("c1 = " + c1);//'c'
        /*
            4.public int indexOf (String str) ` ：返回指定子字符串第一次出現在該字符串內的索引。
            參數：指定的字符串  返回值：從前向後查找參數的字符串在此字符串第一次出現的索引，如果沒有返回-1
         */
        //需求：獲取字符串ca在s對象的索引
//        int index = s.indexOf("cas");
//        System.out.println("index = " + index);//index = 4
        String s = "itcacast";
        //5.public int lastIndexOf(String str)` ：返回指定子字符串最後一次出現的字符串中的索引。 如果不包含，則返回-1。
        //需求：獲取字符串ca在s對象最後一次出現的索引
//        int index2 = s.lastIndexOf("ca");
//        System.out.println("index2 = " + index2);//index2 = 4
        /*
            6.public String substring (int beginIndex) ` ：返回一個子字符串，從beginIndex開始截取字符串到字符串結尾。
            參數：
                beginIndex ：表示要截取的字符串開始的索引(包含索引對應的字符)
         */
        //需求：獲取子字符串：cacast
        String newStr = s.substring(2);
        System.out.println("newStr = " + newStr);//cacast
        /*
            7.public String substring (int beginIndex, int endIndex) ` ：
            返回一個子字符串，從beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。**包頭不包尾**
            參數：
               beginIndex：表示要截取的字符串開始的索引(包含索引對應的字符)
               endIndex： 截取的字符串結束的索引(不包含該索引對應的字符)
         */
        //需求：截取字符串 caca
        String s2 = s.substring(2, 6); //2表示字符第一個c對應起始索引  6 表示字符s對應索引，但是不包含s
        System.out.println("s2 = " + s2);
    }
}

3.轉換功能的方法

• public char[] toCharArray () ：將此字符串轉換爲新的字符數組。
• public byte[] getBytes () ：使用平臺的默認字符集將該 String編碼轉換爲新的字節數組。
• public String toLowerCase() ：使用默認語言環境的規則將此 String所有字符轉換爲小寫。
• public String toUpperCase() ：將此 String所有字符轉換爲大寫，使用默認語言環境的規則。
• public String replace (CharSequence target, CharSequence replacement) ：將與target匹配的字符串使用replacement字符串替換。

代碼演示：

package com.itheima.sh.string_method_03;
/*
    1.public char[] toCharArray () ` ：將此字符串轉換爲新的字符數組。
    2.public byte[] getBytes ()` ：使用平臺的默認字符集將該 String編碼轉換爲新的字節數組。
    3.public String toLowerCase()` ：使用默認語言環境的規則將此 String所有字符轉換爲小寫。
    4.public String toUpperCase()` ：將此 String所有字符轉換爲大寫，使用默認語言環境的規則。
    5.public String replace (CharSequence target, CharSequence replacement) ` ：將與target匹配的字符串使用replacement字符串替換。
        說明：
            參數：
                target：就是要被替換的內容，就是原來就存在的內容
                replacement：就是新的內容
            參數類型：CharSequence屬於String父接口 可以傳遞String對象

 */
public class MethodDemo03 {
    public static void main(String[] args) {
        //1.public char[] toCharArray () ` ：將此字符串轉換爲新的字符數組。
        //定義字符串
//        String s = "abcdefg";
        //將上述字符串轉換爲字符數組
       /* char[] ch = s.toCharArray();
        //遍歷數組
        for (int i = 0; i < ch.length; i++) {
            System.out.println(ch[i]);
        }*/
        //2.public byte[] getBytes ()` ：使用平臺的默認字符集將該 String編碼轉換爲新的字節數組。
//        byte[] buf = s.getBytes();
//        for (int i = 0; i < buf.length; i++) {
//            System.out.print(buf[i]+" ");//97 98 99 100 101 102 103
//        }
//        String buf2 ={97,98,99,100};
        //3.public String toLowerCase()` ：使用默認語言環境的規則將此 String所有字符轉換爲小寫。
        //定義字符串
        String s1 = "ajaHAHA";
        //將上述字符串的大寫字母轉換爲小寫
//        String s2 = s1.toLowerCase();
//        System.out.println("s2 = " + s2);// ajahaha
        //4.public String toUpperCase()` ：將此 String所有字符轉換爲大寫，使用默認語言環境的規則。
        //將上述字符串的小寫字母轉換爲大寫
//        String s3 = s1.toUpperCase();
//        System.out.println("s3 = " + s3);//AJAHAHA
        /*
            5.public String replace (CharSequence target, CharSequence replacement) ` ：將與target匹配的字符串使用replacement字符串替換。
            說明：
                參數：
                    target：就是要被替換的內容，就是原來就存在的內容
                    replacement：就是新的內容
                參數類型：CharSequence屬於String父接口 可以傳遞String對象
         */
        //需求：將上述字符串中的HAHA 變爲 哈哈
        String s3 = s1.replace("HAHA", "哈哈");
        System.out.println("s3 = " + s3);//aja哈哈

    }
}

小結：

轉換方法：

    1.public char[] toCharArray () ` ：將此字符串轉換爲新的字符數組。
    2.public byte[] getBytes ()` ：使用平臺的默認字符集將該 String編碼轉換爲新的字節數組。
    3.public String toLowerCase()` ：使用默認語言環境的規則將此 String所有字符轉換爲小寫。
    4.public String toUpperCase()` ：將此 String所有字符轉換爲大寫，使用默認語言環境的規則。
    5.public String replace (CharSequence target, CharSequence replacement) ` ：將與target匹配的字符串使用replacement字符串替換。
        說明：
            參數：
                target：就是要被替換的內容，就是原來就存在的內容
                replacement：就是新的內容
            參數類型：CharSequence屬於String父接口 可以傳遞String對象

4.分割功能的方法

• public String[] split(String regex) ：將此字符串按照給定的regex（規則）拆分爲字符串數組。
• public String trim()：去掉當前字符串的前後空格，並返回一個新字符串，原字符串不變。

代碼演示：

package com.itheima.sh.string_method_03;
/*
    1.public String[] split(String regex)` ：將此字符串按照給定的regex（規則）拆分爲字符串數組。
    2.public String trim()`：去掉當前字符串的前後空格，並返回一個新字符串，原字符串不變。
 */
public class MethodDemo04 {
    public static void main(String[] args) {
        //1.public String[] split(String regex)` ：將此字符串按照給定的regex（規則）拆分爲字符串數組。
        //定義一個字符串
        /*
            第一次切割之後的字符串數組中的內容 {aa}  剩下的內容：bb,cc
            第二次切割之後的字符串數組中的內容 {aa,bb,cc}
         */
       /* String s = "aa,bb,cc";
        //需求將上述字符串按照逗號進行分割
        //說明：split方法的參數就是切割的規則，最後切割之後生成的字符串數組中不會存在規則
        String[] arr = s.split(",");
        System.out.println(arr.length);//3
        //遍歷數組
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");//aa bb cc
        }*/

        //2.public String trim()`：去掉當前字符串的前後空格，並返回一個新字符串，原字符串不變。
        //定義字符串
        String s = "   it   ca  st   ";
        //調用方法去掉字符串s的前後空格
        String s1 = s.trim();//中間的空格會保留
        System.out.println("s1 = " + s1);//it   ca  st
    }
}

小結：

1.public String[] split(String regex)` ：將此字符串按照給定的regex（規則）拆分爲字符串數組。
2.public String trim()`：去掉當前字符串的前後空格，並返回一個新字符串，原字符串不變。

5.字符串方法總結

1.重要方法：

方法	說明
int length()	獲取字符串的長度
char charAt(int index)	獲取指定索引處的字符
boolean equals(Object obj)	判斷兩個對象的內容是否相同
String concat(String str)	拼接兩個字符串
boolean contains()	判斷字符串中是否包含小字符串
boolean endsWith(String suffix)	判斷字符串是否以指定字符串結尾
boolean startsWith(String prefix)	判斷字符串是否以指定字符串開頭
int indexOf(String str)	獲取一個字符串第一次出現的索引
int lastIndexOf(String str)	獲取一個字符串最後一次出現的索引
String replace(CharSequence target, CharSequence replacement)	將目標字符串target變爲新的字符串replacement
String substring(int beginIndex,int endIndex)	截取字符串的一部分，包含頭不包含尾
substring(int beginIndex)	截取字符串的一部分，截取到最後
char[] toCharArray()	把字符串轉成字符數組
byte[] getBytes()	把字符串轉成字節數組
String toLowerCase()	把字符串的所有字母轉成小寫
String toUpperCase()	把字符串的所有字母轉成大寫
String trim()	去除字符串兩端的空白
String[] split(String regex)	按照指定格式切割字符串
boolean equalsIgnoreCase()	忽略大小寫判斷兩個字符串是否相同

2.String類的方法都有返回值，如果返回的是字符串數據，那麼你一定要操作返回的字符串，不要操作原來的字符串。

package com.itheima.sh.string_method_03;

public class MethodNoticeDemo05 {
    public static void main(String[] args) {
        //定義一個字符串
        String s = "abcdef";
        //截取字符串bcd
        String substring = s.substring(1, 4);//bcd
        //String類的方法都有返回值，如果返回的是字符串數據，那麼你一定要操作返回的字符串，不要操作原來的字符串。
        System.out.println("s = " + s);//這裏是原來的字符串 s = abcdef
        System.out.println("substring = " + substring);//substring = bcd
    }
}

5.String練習(課下完成)

package com.itheima.sh.string_method_test_04;

import java.util.Scanner;

/*
    需求：鍵盤錄入一個字符串，統計字符串中大小寫字母及數字字符個數
        分析：
            鍵盤錄入一個字符串：
            "akajKAJ18"
            取出字符串中的每個字符
            假設取出是 'a' ，怎麼判斷是小寫字母
            小寫字母範圍：[97,122] --->[a,z]
            假設取出的小寫字母賦值給一個變量 num 判斷範圍：num >='a' && num <= 'z'
            大寫：num >='A' && num <= 'Z'
            數字：num >='0' && num <= '9'
    步驟：
        1.創建鍵盤錄入的對象 導包
        2.定義三個變量作爲計數器分別統計三種字符的次數：bigCount(統計大寫) smallCount(小寫) numberCount(數字)
        3.獲取鍵盤錄入的字符串
        4.遍歷錄入的字符串使用 char charAt(int index) 方法取出每個字符
        5.判斷字符是哪種字符，對應的計數器分別+1
        6.在循環外部輸出三種字符的計數器
 */
public class Test01 {
    public static void main(String[] args) {
        //1.創建鍵盤錄入的對象 導包
        Scanner sc = new Scanner(System.in);
        //2.定義三個變量作爲計數器分別統計三種字符的次數：bigCount(統計大寫) smallCount(小寫) numberCount(數字)
        int bigCount = 0;//(統計大寫)
        int smallCount = 0;//(小寫)
        int numberCount = 0;// (數字)
        //3.獲取鍵盤錄入的字符串
        System.out.println("請您輸入一個字符串數據(大小寫字母和數字)：");
        String inputStr = sc.nextLine();
        //4.遍歷錄入的字符串使用 char charAt(int index) 方法取出每個字符
        //"abc"
//        for(int index =0;index < 字符串長度;index++){//index表示索引從0開始，作爲char charAt(int index)方法的參數
        //inputStr.length() 表示獲取字符串長度
        for (int index = 0; index < inputStr.length(); index++) {//index表示索引從0開始，作爲char charAt(int index)方法的參數
            //取出每個字符
            char ch = inputStr.charAt(index);
            // 5.判斷字符是哪種字符，對應的計數器分別+1
            if (ch >= 'a' && ch <= 'z') {
                //小寫字母
                smallCount++;
            } else if (ch >= 'A' && ch <= 'Z') {
                //大寫字母
                bigCount++;
            } else if (ch >= '0' && ch <= '9') {//這裏單引號不要去掉，表示字符數字
                //數字
                numberCount++;
            }
        }
        //6.在循環外部輸出三種字符的計數器
        System.out.println("大寫字母個數是:" + bigCount);
        System.out.println("小寫字母個數是:" + smallCount);
        System.out.println("數字個數是:" + numberCount);
    }
}

3.StringBuilder類講解(掌握)

1、原理介紹

1.屬於java.lang包下的，不需要導包

2.StringBuilder類表示字符串緩衝區，就是一個存儲字符串數據的容器，暫時存儲數據。字符串緩衝區中的字符串可以別改變

3.可以向StringBuilder字符串緩衝區中添加任何類型的數據(布爾 整數 小數)，但是最後都變爲一個字符串了。

10 整數 加入緩衝區之後---》"10"
true 布爾 加入緩衝區之後---》"true"

4.StringBuilder類底層是一個字符數組，默認大小是16

5.既然底層是一個字符數組，那麼字符串緩衝區是如何支持改變的呢？

2.StringBuilder類的構造方法

方法名	說明
public StringBuilder()	創建一個空白可變字符串對象，不含有任何內容
public StringBuilder(String str)	根據字符串的內容，來創建可變字符串對象

代碼演示：

package com.itheima.sh.stringbuilder_05;
/*
    構造方法：
        1.public StringBuilder()創建一個空白可變字符串對象，不含有任何內容
        2.public StringBuilder(String   str)根據字符串的內容，來創建可變字符串對象
 */
public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //1.public StringBuilder()創建一個空白可變字符串對象，不含有任何內容
        //由於toString
        StringBuilder sb = new StringBuilder();
        //輸出sb
        System.out.println("sb = " + sb);
        //2.  2.public StringBuilder(String   str)根據字符串的內容，來創建可變字符串對象
        StringBuilder sb2 = new StringBuilder("abc");
        System.out.println("sb2 = " + sb2);//sb2 = abc
    }
}

小結：

構造方法：
1.public StringBuilder()創建一個空白可變字符串對象，不含有任何內容
2.public StringBuilder(String str)根據字符串的內容，來創建可變字符串對象

3.方法講解

package com.itheima.sh.stringbuilder_05;
/*
    方法：
    1. int length() 返回長度（字符數）。
    2. StringBuilder append(int i) 將參數放到字符串緩衝區末尾
            參數：
                i:要存儲到字符串緩衝區中的數據
            返回值：是一個StringBuilder類
        注意：由於append方法返回值是一個StringBuilder類的對象，所以可以鏈式編程
    3.反轉方法：StringBuilder reverse() 將此字符序列用其反轉形式取代。
        舉例：源字符串：abcd  反轉之後的：dcba
    4. String toString() 將字符串緩衝區轉換爲String對象
 */
public class StringBuilderDemo03 {
    public static void main(String[] args) {
        //創建字符串緩衝區對象
//        StringBuilder sb = new StringBuilder();
        //向字符串緩衝區中添加數據
//        StringBuilder sb2 = sb.append(true);
        /*sb.append(true);
        sb2.append(10);*/
        //使用鏈式編程向字符串緩衝區中添加數據
        //因爲append方法返回的是一個StringBuilder類的對象，所以可以使用對象繼續調用StringBuilder類的方法
//        sb.append(true).append(10);
//        System.out.println("sb = " + sb);//"true10"
        StringBuilder sb = new StringBuilder("楊冪").append("鎖哥").append("柳巖");
        System.out.println("sb = " + sb);//楊冪鎖哥柳巖
        //對sb內容反轉 StringBuilder reverse()
        sb.reverse();
        System.out.println("反轉後的內容:"+sb);//巖柳哥鎖冪楊
        //4. String toString() 將字符串緩衝區轉換爲String對象
        String s = sb.toString();
        System.out.println("s = " + s);//巖柳哥鎖冪楊
    }
}

小結：

​ 1. int length() 返回長度（字符數）。

​ 2.StringBuilder append(int i) 將參數放到字符串緩衝區末尾
​ 參數：
​ i:要存儲到字符串緩衝區中的數據
​ 返回值：是一個StringBuilder類
​ 注意：由於append方法返回值是一個StringBuilder類的對象，所以可以鏈式編程
3.反轉方法：StringBuilder reverse() 將此字符序列用其反轉形式取代。
​ 舉例：源字符串：abcd 反轉之後的：dcba

​ 4.String toString() 將字符串緩衝區轉換爲String對象

4.StringBuilder和String相互轉換

package com.itheima.sh.stringbuilder_05;
/*
    StringBuilder和String相互轉換:
        1.將String轉換爲StringBuilder:
         構造方法：
            StringBuilder(String str)
         追加方法：
            StringBuilder append(String str)
        2.將StringBuilder轉換爲String
             String toString() 
 */
public class StringBuilderDemo04 {
    public static void main(String[] args) {
        //創建字符串緩衝區對象將String轉換爲字符串緩衝區
        String s = "abc";
        StringBuilder sb = new StringBuilder(s);

        //將StringBuilder轉換爲String:String toString()
        String s1 = sb.toString();
        System.out.println("sb = " + sb);//abc
        System.out.println("s1 = " + s1);//abc

    }
}

小結：

StringBuilder和String相互轉換:
1.將String轉換爲StringBuilder:
構造方法：
StringBuilder(String str)
追加方法：
StringBuilder append(String str)
2.將StringBuilder轉換爲String
String toString()