一、操作字串及區別及相關考點

	1.java中常見的操作字串有什么？
        String  StringBuffer  StringBuilder
    2.String，StringBuffer，StringBuilder 的區別
        （1）String修飾的是不可變的，String一旦被創建，里面的值便不可被改變，如果需要改變就需要創建新的物件，
        （2）StringBuffer和StringBuilder可以再原有物件的基礎上進行操作：
        	   ①StringBuffer從jdk1.0開始存在，屬于執行緒安全的類，性能低
               ②StringBuilder從jdk1.5開始存在，屬于執行緒不安全的類，性能高
               ③ StringBuffer一般在多執行緒環境下使用
                 StringBulder一般在單執行緒環境下使用  
        （3）效率： StringBuilder>StringBuffer>String

String類：   public final class String {}
StringBuilder類   public final class StringBuilder{}

	1. String類能否被繼承？
        不能，String類是被final修飾的類，該類是最終類，不能被繼承，
    2. String底層存盤資料的型別是什么？
        JDK1.9之前是char[]來存盤資料，1.9之后用byte[]來存盤資料，原因是我們存盤的大多數資料都是一個位元組，這樣的情況下用char就會浪費一個位元組，造成記憶體的浪費，
    3. String型別描述的字串內容是常量，一旦定義是不可被改變的，因此會被虛擬機放在常量池中，如果后續我們的代碼中有相同的字串內容則直接可以使用常量池中已有的物件，無需創建新的物件，提高了性能，
    4. 請問下面的代碼會創建幾個物件？分別存放在什么地方？
        String str1="he";   //一個物件，存放在常量池
        String str2=new String("he");  //兩個物件，一個在常量池中，一個在堆記憶體中
	5. String str="abcdef";
       String str1="abc"+"def";
       System.out.println(str==str1);  //true，因為常量有優化機制，而變數沒有
	6. 既然StringBuilder類的物件本身可以修改，那么為什么還會有回傳值呢？
        	回傳值回傳的是自身，目的為了連續呼叫，例如： s.reverse().append("a").insert(4,"s");
	7. 如何實作StringBuilder型別與String型別之間的轉換呢？
        	String轉StringBuilder： StringBuilder sb=new StringBuilder(s)；
        	StringBuilder轉String： String s=sb.toString();

二、String的常用方法

（一）常用的構造方法

		String ()       使用無參方式構造物件得到空字串
        String(byte[] bytes,int offset,int length)     
        		使用bytes陣列中下標從offset位置開始的length個位元組來構造物件
        String(byte[] bytes)      使用bytes陣列中的所有內容構造物件
        String(char[] value,int offset,int length)     
        		使用bytes陣列中下標從offset位置開始的length個位元組來構造物件
        String(char[] value)      使用value陣列中的所有內容構造物件
        String(String original)     根據引數指定的字串內容來構造物件，新創建物件為引數物件的副本

public class Test1 {
    public static void main(String[] args) {
        // 使用無參構造方式創建物件并列印
        String str=new String();
        System.out.println("str= "+str);
        // 創建一個位元組型陣列str1
        byte[] str1={88,89,45,88,52,89,98,58};
        // 使用引數指定的byte陣列創建物件并列印
        String str2= new String(str1,2,5);
        System.out.println("str2= "+str2);
        // 使用byte陣列創建物件并列印
        String str3=new String(str1);
        System.out.println("str3= "+str3);
        // 創建一個字符型物件str4
        char[] str4={88,89,90,91,99,100};
        System.out.println("str4= "+str4);
        // 使用引數指定的char陣列創建物件并列印
        String str5=new String(str4,2,3);
        System.out.println("str5= "+str5);
        // 使用char陣列創建物件并列印
        String str6=new String(str4);
        System.out.println("str6= "+str6);
    }
}

(二) 常用的成員方法1

	String toString()          回傳字串本身
    byte[] getBytes()          將當前字串內容轉換為byte陣列并回傳
    char[] toCharArray()          將當前字串內容轉換為char陣列并回傳
    char  charAt(int index)       用于回傳字串指定位置的字符
    int length()            回傳字串字符序列的長度
    boolean isEmpty()             判斷字串是否為空

public class Test2 {
    public static void main(String[] args) {
        // 創建一個String物件賦值并輸出
        String str=new String("abcdef");
        System.out.println(str);
        // 將str轉為陣列并輸出
        byte[] str1=str.getBytes();
        for(Object o:str1){
            System.out.println(o);
        }
        System.out.println("-----------------------------------------------");
        // 輸出字串位置3的字符
        System.out.println("字串中下標為3的元素為："+str.charAt(3));
        // 輸出字串長度
        System.out.println("字串的長度為："+str.length());
        // 判斷字串是否為空
        System.out.println(str.isEmpty()?"字串為空":"字串不為空");
    }
}

(三) 常用的成員方法2

	String concat(String str)       用于實作字串的拼接
	boolean contains(CharSequence s)       用于判斷當前字串是否包含引數指定的內容
	String toLowerCase()         回傳字串的小寫形式
    String toUpperCase()         回傳字串的大寫形式
	String trim()            回傳去掉前面和后面空白的字串
	boolean startsWith(String prefix)       判斷字串是否以引數字串開頭
	boolean startsWith(String prefix，int toffset)       
    						從指定位置判斷字串是否以引數字串開頭boolean
    boolean endsWith(String suffix)     判斷字串是否以引數字串結尾

public class Test3 {
    public static void main(String[] args) {
        String arr=new String("  abhdhjdGHUJbbff ");
        System.out.println("arr=["+arr+"]");
        System.out.println("arr中包含as："+arr.contains("as"));
        System.out.println("arr中包含ab："+arr.contains("ab"));
        System.out.println("arr的小寫形式："+arr.toLowerCase());
        System.out.println("arr的大寫形式："+arr.toUpperCase());
        System.out.println("去掉前后空格的arr："+arr.trim());
        System.out.println("-----------------------------------------");
        // 判斷字符轉是否以a開頭
        System.out.println(arr.startsWith("a")?"字串以a開頭":"字串不以a開頭");
        // 判斷字符轉是否以a結尾
        System.out.println(arr.endsWith("a")?"字串以a結尾":"字串不以a結尾");
    }
}

(三) 常用的成員方法3

	boolean equals(Object object)   用于比較字串是否相等并回傳
    int hasgCode()    獲取呼叫物件的哈希碼值
    boolean equalsIgnoreCase(String anotherString)  
               用于比較字串內容是否相等并回傳，不考慮大小寫是否相等
    String sbustring(int beginIndex,int endIndex)
           回傳字串中從下標beginIndex開始到endIndex結束的子字串
    String substring(int beginIndex)    
           回傳字串中從下標beginIndex開始到字串結尾的子字串

(四) 常用的成員方法4

	int indexOf(int c)    用于回傳當前字串中引數c指定的字符喜歡第一次出現的下標
    int indexOf(int c,int index)  用于從index位置開始查找c指定的字符
    int indexOf(String s)   在字串中檢索s回傳其第一次出現的位置，若找不到回傳-1
    int indexOf(String s,int index)  從字串的index位置開始檢索自渡川s第一次出現的位置
    int lastIndex(int c)    用于回傳c指定的字符最后一次出現的下標
    int lastIndex(int c,int index)  用于從index位置開始查下好c指定字符出現的下標
    int lastIndexOf(String s)     回傳s指定字串最后一次出現的下標
    int lastIndexOf(String s,int index)   用于從index位置開始檢索s第一次出現的下標

三、StringBuilder常用方法

（一）常用的構造方法

	StringBuilder()           使用無參方式構造物件，容量為16
    Stringbuider(int c)          根據引數指定的容量來構造物件，容量為引數指定大小
    StringBuilder(String s)          根據引數指定的字串來構造物件，容量為：16＋字串長度

（二）常見的成員方法

	int capacity()             用于回傳呼叫物件的容量
    int length()             用于回傳字串的長度，也就是字符的個數
    StringBuilder insert(int offest,String s)
        	            在offest處插入字串s并回傳呼叫物件的參考
    StringBuilder append(String s)          追加字串
    StringBuilder deleteCharAt(int index)      將當前字串中下標為index位置的單個字符洗掉
    StringBuilder delete(int start,int end)      洗掉字串從start到end，也就是洗掉字串全部
    StringBuilder replace(int start,int end,String str)       替換字串
    StringBuilder reverse()                  字串反轉

（三）StringBuilder常見方法練習

public class Test1 {
    public static void main(String[]  args) {
        // 使用無參方式構造物件并輸出
        StringBuilder s1 = new StringBuilder();
        System.out.println("無參構造的s1="+s1);
        // 輸出物件的容量
        System.out.println("s1的容量的為："+s1.capacity());
        // 輸出字串長度，也就是s1里面存盤的字串個數
        // 由于創建時是無參，所以s1為什么都沒有，長度為0
        System.out.println("s1的長度為："+s1.length());
        // 追加字串
        s1.append("a");
        s1.append("b");
        s1.append("c");
        s1.append("d");
        s1.append(5);
        s1.append(6);
        System.out.println("追加過字串后的s1："+s1);
        // 在指定位置插入字串
        s1.insert(2,4);
        System.out.println("在2位置添加字串4后的s1："+s1);
        // 洗掉指定位置的字符
        s1.deleteCharAt(1);
        System.out.println("洗掉1位置元素后的s1："+s1);
        // 字串反轉
        s1.reverse();
        System.out.println("反轉過的s1："+s1);
        System.out.println("-----------------------------------------------------------");
        // 使用指定的字串構造物件并輸出
        StringBuilder s2 = new StringBuilder("huixianchangcun");
        System.out.println("指定引數構造的s2="+s2);
        // 輸出物件的容量
        System.out.println("s2的容量的為："+s2.capacity());
        // 輸出字串長度，也就是s1里面存盤的字串個數
        System.out.println("s2的長度為："+s2.length());
        // 在指定位置插入字串
        s2.insert(2,4);
        System.out.println("在2位置添加字串4后的s2："+s2);
        // 洗掉指定位置的字符
        s2.deleteCharAt(2);
        System.out.println("洗掉2位置元素后的s2："+s2);
        // 字串反轉
        s2.reverse();
        System.out.println("反轉過的s2："+s2);
        System.out.println("-------------------------------------------------------");
        // 替換字串
        s2.replace(3,8, String.valueOf(s1));
        System.out.println("在s2指定位置用s1替換過后的s2："+s2);
    }
}