4.1常用對象API（String類）

1.特點

1. 字符串對象一旦被初始化就不會被改變
2. 字符串緩衝區（常量池），新建字符串時先去常量池找，有就把地址返回，沒有就創建。

例子：
1.
String s = "abc";  //存儲在字符串常量池中
String s1 = "abc";
System.out.println(s == s1);   //true

2.
String s = "abc";  //在常量池中產生一個字符串對象，共享的
String s1 = new String("abc");  //初始化"abc"字符串對象。新創建的字符串是"abc"的副本。s1特有
                    //就是在堆內存裏面產生兩個對象，一個new，一個字符串對象。
System.out.println(s == s1);    //flase
System.out.println(s.equals(s1));  //String類是Object的子類，它複寫了equals()方法，這裏比較的不是地址了，是內容。
                                        //其實就是比較字符串內容，true

2.構造函數

例子：
1.
String s = new String();  //等效與String s = "";  不等效String s = null;
byte[] arr = {65,66,67,68};
String s1 = new String(arr);  //將字節數組變成字符串，ABCD

2.
char[] arr = {'C','z','q','G','s'};
String s = new String(arr,0,3);  //將字符數組指定部分變成字符串，這裏從0開始，取3個，即Czq

3.方法：

按照面對對象的思想對字符串進行功能分類
"abcd"

1.獲取：
    1.1. 獲取字符串中字符的個數。
                            int length();
    1.2根據位置獲取字符。
                            char charAt(int index);
    1.3根據字符/字符串 獲取在字符串中第一次出現的位置。不存在返回-1
                            int  indexOf(int ch);      從0開始
                            int indexOf(int ch, int fromIndex);從指定位置進行ch的查找，第一次出現的位置
                            int indeOf(String str);
                            int indeOf(String str, int fromIndex);

                            int lastIndexOf(int ch);       從最後一個開始
                            int lastIndexOf(int ch, int fromIndex);
                            int lastIndeOf(String str);
                            int lastIndeOf(String str, int fromIndex);
    1.4獲取字符串中的一部分字符串。也叫子串。
                            String  substring(int beginIndex, int endIndex)   包含begin,不包含end
                            String  substring(int beginIndex)

2.轉換：
    2.1將字符串變成字符串數組（字符串的切割）:涉及到正則表達式
                            String[]  split(String regex)    regex - 定界正則表達式
                            String[]  split(String regex, int limit) limit 切割成幾段
    2.2將字符串轉換成字符數組。反過來用字符串構造函數。
                                            或者使用靜態方法：String copyValueOf(char[] data)
                                                          String copyValueOf(char[] data,int offset, int count) 
                            String[]  toCharArray();
    2.3將字符串變成字節數組
                            byte[]  getByte();  一個漢字兩個字節，是負的
    2.4將字符串中的字母轉換成大小寫
                            String  toUpperCase() : 大寫
                            String  toLowerCase():  小寫
    2.5將字符串中的內容進行替換
                            String replace(char oldChar, char newChar);    如果沒有找到舊字符，就不新建字符串，直接在常量池中調用原字符串對象
                            String replace(CharSequence target, CharSequence replacement);   字符串替換，String類是CharSequence接口的子類。（它所有的子類都可以替換）
    2.6將字符串兩端的空格去掉,返回字符串的副本
                            String trim();
    2.7將字符串進行連接
                            String   concat(String str)  如果str長度爲0，則不創建新字符串，直接在常量池中調用原字符串對象
                            和 + 等效，但是上面的更專業。
    2.8將基本數據類型將換成字符串，靜態方法
                                String valueOf(boolean b)
                                String valueOf(char c)
                                String valueOf(char[] data)
                                String valueOf(char[] data,int offset,int count)
                                String valueOf(double d)
                                String valueOf(float f)
                                String valueOf(int i)
                                String valueOf(long l)
                                String valueOf(Object obj)
3判斷：
    3.1兩個字符串內容是否相同
                            boolean equals(Object obj) 區分大小寫
                            boolean equalsIgnoreCase(String str) 忽略大小寫
    3.2字符串中是否包含指定字符串
                            boolean contains(String str)
    3.3字符串是否以指定字符串開頭/結尾
                            boolean startsWith(String);
                            boolean endsWith(String);

4.比較：按字典順序比較。等於，返回0。小於，返回一個負數。大於返回一個正數
                            int compareTo(String anotherString)         

4.intern方法：操作字符串池，如果字符串池中包含此字符串，則返回池中的字符串。如果池中沒有，在則在池中新建一個並返回新的字符串對象。開發基本不用

String s1 = new String("abc");   //"abc"是在對象中被操作，池中沒有
String s2 = s1.intern();     //相當於將新的"abc"存到池裏
System.out.println(s1==s2);   //false

String s1 = "abc";    在池中新建
String s2 = s1.intern();
System.out.println(s1==s2);   //true

5.StringBuffer:就是字符串緩存區。（內部就相當於數組，默認16個字符）
用於存儲數據的容器。
特點：

 1.長度可變
 2.可以存儲不同類型數據
 3.最終要轉成字符串進行使用。toString()
 4.對字符串可以修改 

具備的功能： 增刪改查 C(create增)U(update改)R(read查)D(delete刪)

 1.添加：
        StringBuffer   append(data);     追加到尾部
        StringBuffer      insert(int offset, data);   插入到指定位置
2.刪除：
        StringBuffer delete(int start, int end);  包含頭，不包含尾
        StringBuffer deleteCharAt(int index);  刪除指定位置的元素
        delete(0,sb.length());   清空
 3.修改：
        StringBuffer replace(start,end,string); 替換
    void              setChatAt(index, char);  替換一個字符
 4.查找：
        char charAt(index);
        int indexOf(String);
        int lastIndexOf(String);
 5.其他：
        設置長度： void setLength(int );  
                sb.setLength(0);   清空（瞭解）
        反轉：      StringBuffer reverse

注意：

可變長度數組：  容量不夠就新建一個數組，把原來的元素複製過來，然後添加新的元素。容量是原來的一倍不等。
            能確定容器容量時最好在初始化時就確定，效率高些。

1. StringBuilder： jdk1.5以後出現了和StringBuffer一模一樣的對象。

不同的是：
StringBuffer是線程同步的。如果是單線程每次運行都要判斷鎖，效率低。安全，通常用於多線程。
StringBuilder是線程不同步的。是補充的單個線程的等價類，單線程時優先使用StringBuilder，由於不執行同步，所以速度更快。

原理：

class StringBuffer
 {
        Object lock;
        public StringBuffer append(int x)
        {
            synchronized(lock)
            {}
        }   

        public StringBuffer delete(int start, int end)
        {
            synchronized(lock)
            {}
        }
 }