String常用操作

常量池：

字元串一旦被初始化就不會被改變

        String s="123";
        s="abc";
        System.out.print(s);

這段代碼看上去s的值是被改變了的，實際上123就是一個對象，他存在於常量池中，abc也是一個對象，s的值實際上是指向123或者abc的地址。

所以當我們使用String s="123";來定義字元串的時候，會先查看常量池中是否有123，有就直接賦值123的地址，如果沒有就創建123。

   1     String s="123";
   2     String s1=new String("123");
   3     System.out.println(s==s1);
   4     System.out.print(s.equals(s1));
結果：

　　　　false

　　　　true

2中，實際上是創建了兩個對象，一個new,一個堆記憶體中。equals本來和==一樣是比較地址值得，但是String類重寫了equals方法，比較的是內容。 

獲取

1.1獲取字元串中字元的長度（個數）

int length()

1.2根據位置獲取字元 

char charAt(int index)

1.3根據字元（子串）獲取其在字元串中第一次出現的位置　　　　

char indexOf(int ch)

char indexOf (int ch,int fromIndex)從指定位置進行查找

char indexOf(String str)

char indexOf (String str,int fromIndex)

 上面的是從前向後找，下麵的是從後向前找

char lastIndexOf(int ch)

char lastIndexOf (int ch,int fromIndex)從指定位置進行查找

char lastIndexOf(String str)

char lastIndexOf (String str,int fromIndex)

 1.4獲取字元串中的子串

String substring(int beginIndex,int endInedx)包含befin不包含end

String substring(int beginIndex)

轉換

1.1將字元串變成字元串數組

String[] split(String regex) 這裡的切割點有時會涉及到正則表達式，所以要用\將特殊字元轉化成普通字元。註意\.也是正則規則中的一部分

public class Text {
    public static void main(String[] args){
        String s="張三.李四.王五";
        String[] arr=s.split("\\.");
        for(int i=0;i<arr.length;i++)
        System.out.println(arr[i]);    
    }
}

1.2將字元串變成字元數組

char[] toCharArray();

1.3將字元串變成位元組數組

byte[] getBytes();

1.4將字元串中的字母轉換大小寫

String toUpperCase();
String toLowerCase();

1.5將字元串中的內容進行互換

String replace(String oldst,String newst)
String replace(char oldch,char newch)

1.6將字元串兩端的空格去掉

String trim();

1.7將字元串進行連接

String concat(String);

判斷

1.1比較兩個字元串是否相同

boolean equals(anObject)

boolean equalsIgnoreCase(anotherString)不區分大小寫

1.2判斷字元串中是否包含指定字元串

boolean contains(String str)

1.3字元串是否以指定字元串開頭（結尾）

boolean startsWith(String)

boolean endsWith(String)

1.4比較兩個字元串的字典順序大小

int compareTo(anotherString);

int compareToIgnoreCase(anotherString)不區分大小寫

 intern

• 當調用intern方法時，如果池已經包含與equals(Object)方法確定的相當於此String對象的字元串，則返回來自池的字元串。 否則，此String對象將添加到池中，並返回對此String對象的引用。

  （實際上就是看對象的值123在池當中有沒有，如果沒有那我就在池中創建一個，如果有那我就直接拿來用）

  public class Text {
      public static void main(String[] args){
          String s=new String("123");
          String s1=s.intern();
          String s2=s1.intern();
          System.out.println(s==s1);    
          System.out.println(s1==s2);    
      }
  }
  結果
  false
  true

StringBuffer

就是字元串緩衝區，用於存儲數據的容器

特點：1長度是可變的

           2可以存儲不同數據類型

　　　3最終要轉成字元串進行使用

　　　4可對字元串進行修改

既然是個容器那麼它具備什麼功能呢？

1添加

StringBuffer append(data)在結尾進行添加
StringBuffer insert(index,data)在指定位置插入

public class Text {
    public static void main(String[] args){
        StringBuffer s=new StringBuffer();
        s.append("1").append("2").append("b");
        s.insert(1, "a");
        System.out.println(s);        
    }
}
結果:1a2b

2刪除

StringBuffer delete(start,end);包含頭不包含為尾
StringBuffer deleteCharAt(int index);刪除指定位置的元素

3查找

char charAt(index)返回指定位置字元

int indexOf(str);返回子串第一次出現的位置

int kastIndexOf(str)從字元串末尾開始查詢

4修改

StringBuffer replace(start, end, str);

void setCharAt(index, ch);只修改一個字元。註意它沒有返回值類型

5

StringBuffer reverse();將字元串頭尾進行對調

 new StringBuffer()初始化的預設長度為16 

 new StringBuffer(index)可以指定其初始化的長度（如果可以確定數據的大小，最好使用這個，可以避免開闢空間和進行運算）

 StringBuilder

jdk1.5以後出現了功能和StringBuffer一模一樣的對象，即Stringbuilder

不同的是：

Stringbuilder是線程不同步的，通常用於單線程，效率高，因為不用每次都判斷鎖。

StringBuffer線程同步，通常用於多線程，安全。（如果刪除和添加同時進行了，那麼就會造成安全隱患）

    Object lock;
        public StringBuffer append(int x){
            synchronized(lock){
                
            }
        }
        public StringBuffer delete(int start,int end){
            synchronized(lock){
                
            }
        }

JDK升級的目的：

1簡化書寫

2提高效率

3增加安全性