Java經常使用類-String類

字符串相關的類：String

String類：表明字符串，Java 程序中的全部字符串字面值（如 "abc" ）都做 爲此類的實例實現。

• String是一個final類，表明不可變的字符序列
  • 當字符串從新賦值時，須要從新指定內存區域，不能使用原有的value進行賦值
  • 當對現有的字符串進行鏈接操做時，也須要從新指定內存區域賦值，也不能 在原有的value上進行賦值
  • 當調用String的replace()方法修改指定字符或字符串時，也須要從新指定內存區域進行賦值
  • 也就是說對String的任何修改都是從新的造一個
• 字符串是常量，用雙引號引發來表示。它們的值在建立以後不能更改
• String內部定義了final char value[] 用於存儲字符串數據
• String實現了Serializable接口，表示字符串是支持序列化的，實現了 Comparable接口，表示String能夠比較大小
• 經過字面量的方式(區別於new)給一個字符串賦值，此時的字符串的值是聲明在字符串常量池中的
• 字符串常量池是不會存儲相同內容的字符串

public void test1(){
        String s1 = "abc";//字面量的方式
        String s2 = "abc";

        System.out.println(s1 == s2);// ture , 比較的是s1和s2的地址值
        s1 = "hello";

        System.out.println(s1); // hello
        System.out.println(s2); // abc

        String s3 = "abc";
        s3 += "def";
        System.out.println(s3); // abcdef
        System.out.println(s2 == s3); // false , 此時的s2和s3的地址值已經不一樣


        String s4 = "abc";
        String s5 = s4.replace('a' , 'd');
        System.out.println(s4); // abc
        System.out.println(s5); // dbc
    }

1. String的實例化方式

• 經過字面量定義的方式：此時的s1和s2的數據是聲明在方法區的字符串常量池中
• 經過new + 構造器的方式：此時的s3和s4保存的地址，是數據在堆空間中開闢空間之後對應的地址值

public void test2(){

        String s1 = "Java";
        String s2 = "Java";

        String s3 = new String("Java");
        String s4 = new String("Java");

        System.out.println(s1 == s2); // true
        System.out.println(s1 == s3); // false
        System.out.println(s1 == s4); // false
        System.out.println(s3 == s4); // false



        Person p1 = new Person("Tom",18);
        Person p2 = new Person("Tom",18);
        System.out.println(p1.name.equals(p2.name)); // true , String重寫了equals方法，此時比較的就是內容了
        System.out.println(p1.name == p2.name); // true , 兩個對象裏面仍是字面量定義的方式賦值
    }

注：兩個對象裏面仍是字面量定義的方式賦值

面試題

String s = new String("abc")方式建立對象，在內存中建立了幾個對象？

兩個，一個是堆空間的new的結構，一個是char[]對應的常量池中的數據 "abc"

2. 字符串的特性

重點：

• 常量與常量的拼接結果在常量池中，且常量池中不會存在相同內容的常量
• 只要其中一個是變量，結果就在堆中
• 若是拼接的結果調用intern()方法，返回值就是在常量池中

public void test3(){
        String s1 = "Java";
        String s2 = "Python";

        String s3 = "JavaPython";
        String s4 = "Java" + "Python";
        String s5 = s1 + "Python";
        String s6 = s1 + s2;

        System.out.println(s3 == s4); // true

        System.out.println(s3 == s5); // false
        System.out.println(s4 == s5); // false
        System.out.println(s3 == s6); // false

        String s7 = s5.intern();
        System.out.println(s7 == s3); //true
    
    }

特別注意：當 final String s1 = 「java」，這個也就至關於一個常量了

3. 面試題：

good and best

這裏能夠參考以前的Java的值傳遞

若在scr前面加一個this，狀況會是怎樣？

package com.atguigui.exer;

/**
 * @author MD
 * @create 2020-07-12 9:41
 */
public class StringTest {

    String str = new String("good");
    char[] ch = {'t','e','s','t'};

    public void change(String str, char ch[]){
        this.str = "test ok";
        ch[0] = 'b';
    }

    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str,ex.ch);
        System.out.println(ex.str);
        System.out.println(ex.ch);
        // test ok
        // best
        
    }
}

4. String經常使用的方法

注意String的不可變性，原字符不變

• int length()：返回字符串的長度： return value.length
• char charAt(int index)： 返回某索引處的字符return value[index]
• boolean isEmpty()：判斷是不是空字符串：return value.length == 0
• String toLowerCase()：使用默認語言環境，將 String 中的全部字符轉換爲小寫
• String toUpperCase()：使用默認語言環境，將 String 中的全部字符轉換爲大寫
• String trim()：返回字符串的副本，忽略前導空白和尾部空白
• boolean equals(Object obj)：比較字符串的內容是否相同
• boolean equalsIgnoreCase(String anotherString)：與equals方法相似，忽略大 小寫
• String concat(String str)：將指定字符串鏈接到此字符串的結尾。 等價於用「+」
• int compareTo(String anotherString)：比較兩個字符串的大小 涉及到字符串排序
• String substring(int beginIndex)：返回一個新的字符串，它是此字符串的從 beginIndex開始截取到最後的一個子字符串。
• String substring(int beginIndex, int endIndex) ：返回一個新字符串，它是此字 符串從beginIndex開始截取到endIndex(不包含)的一個子字符串。
• boolean endsWith(String suffix)：測試此字符串是否以指定的後綴結束
• boolean startsWith(String prefix)：測試此字符串是否以指定的前綴開始
• boolean startsWith(String prefix, int toffset)：測試此字符串從指定索引開始的 子字符串是否以指定前綴開始
• boolean contains(CharSequence s)：當且僅當此字符串包含指定的 char 值序列 時，返回 true，也就是字符串A中是否包含字符串B
• int indexOf(String str)：返回指定子字符串在此字符串中第一次出現處的索引
• int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出 現處的索引，從指定的索引開始
• int lastIndexOf(String str)：返回指定子字符串在此字符串中最右邊出現處的索引
• int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最後 一次出現處的索引，從指定的索引開始反向搜索
• 注：indexOf和lastIndexOf方法若是未找到都是返回-1
• String replace(char oldChar, char newChar)：返回一個新的字符串，它是 經過用 newChar 替換此字符串中出現的全部 oldChar 獲得的。
• String replace(CharSequence target, CharSequence replacement)：使 用指定的字面值替換序列替換此字符串全部匹配字面值目標序列的子字符串。
• String replaceAll(String regex, String replacement) ： 使用給 定 的 replacement 替換此字符串全部匹配給定的正則表達式的子字符串。
• String replaceFirst(String regex, String replacement) ： 使用給 定 的 replacement 替換此字符串匹配給定的正則表達式的第一個子字符串。
• boolean matches(String regex)：告知此字符串是否匹配給定的正則表達式
• String[] split(String regex)：根據給定正則表達式的匹配拆分此字符串。
• String[] split(String regex, int limit)：根據匹配給定的正則表達式來拆分此 字符串，最多不超過limit個，若是超過了，剩下的所有都放到最後一個元素中。

5. String與基本數據類型轉換

String ---> 基本數據類型、包裝類

• 調用包裝類的靜態方法：parseXxx(str)

基本數據類型、包裝類 --- >字符串

• 調用String的valueOf(xxx)

public void test2(){
        String str = "123";
        
        int num = Integer.parseInt(str);
        
        String str1 = String.valueOf(num);
    }

String ---> char[] : 調用String的toCharArray()

char[] ---> String: 調用String的構造器

public void test3(){
        String str = "asdf123";

        char[] charArray = str.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }

        String str1 = new String(charArray);
        System.out.println(str1);

    }

編碼：String ---> byte[] :調用String的getBytes()
解碼：byte[] ---> String : 調用String的構造器

/**
     * 編碼：字符串 -->字節 (看得懂的---->看不懂的二進制數據)
     * 解碼：字節 ---> 字符串(看不懂的二進制數據---->看得懂的)
     * @throws UnsupportedEncodingException
     */
    @Test
    public void test4() throws UnsupportedEncodingException {
        String str = "abc123你好";
        byte[] bytes = str.getBytes(); // 使用默認的字符集進行轉換 UTF-8 編碼
        System.out.println(Arrays.toString(bytes));

        String str1 = "abc123你好";
        byte[] bytes1 = str1.getBytes("gbk"); // 指定編碼格式
        System.out.println(Arrays.toString(bytes1));


        System.out.println("---------------------");
        String str2 = new String(bytes); // 解碼，使用的默認的格式
        System.out.println(str2);

        String str3 = new String(bytes1 , "gbk");// 解碼，使用的指定的格式
        System.out.println(str3);
    }

6. StringBuffer、StringBuilder ？

面試題：對比String、StringBuffer、StringBuilder ？

• String(JDK1.0)：不可變字符序列 ，效率最低
• StringBuffer(JDK1.0)：可變字符序列、效率低、線程安全 同步
• StringBuilder(JDK 5.0)：可變字符序列、效率高、線程不安全
• 底層都使用char[]存儲

注意：做爲參數傳遞的話，方法內部String不會改變其值，StringBuffer和StringBuilder 會改變其值

源碼分析：
String str = new String(); // char[] value = new char[0];
String str1 = new String("abc"); // char[] value = new char[]{'a','b','c'};

StringBuffer sb1 = new StringBuffer(); // char[] value = new char[16];底層建立一個長度16的char型數組
StringBuffer sb1 = new StringBuffer("abc"); // char[] value = new char["abc".length()+16];

問題1：

注意這個是裏面 裏面數據的長度，

public void test5(){
        StringBuffer sb1 = new StringBuffer();
        System.out.println(sb1.length()); // 0

        StringBuilder sb2 = new StringBuilder("abc");
        System.out.println(sb2.length()); // 3

    }

問題2：

擴容問題，若是要添加的數據放不下了，那就須要擴容數組，默認狀況下，擴容爲原來的2倍+2，將原有數組中的數據複製到新的數組中去

String -----> StringBuffer、StringBuilder : 調用StringBuffer、StringBuilder構造器就能夠了

StringBuffer、StringBuilder -----> : 調用String的構造器

StringBuffer類的經常使用方法和StringBuilder相似

• StringBuffer append(xxx)：提供了不少的append()方法，用於進行字符串拼接
• StringBuffer delete(int start,int end)：刪除指定位置的內容
• StringBuffer replace(int start, int end, String str)：把[start,end)位置替換爲str
• StringBuffer insert(int offset, xxx)：在指定位置插入xxx
• StringBuffer reverse() ：把當前字符序列逆轉
• public int indexOf(String str)
• public String substring(int start,int end)
• public int length()
• public char charAt(int n )
• public void setCharAt(int n ,char ch)

總結：

• 增 ：append
• 刪：delete
• 改：setCharAt，replace
• 查：charAt
• 插入：insert
• 長度：length

面試題：

public void testStringBuffer(){
        String str = null;
        StringBuffer sb = new StringBuffer();
        sb.append(str);

        System.out.println(sb.length()); // 4

        System.out.println(sb); //  "null" 這個是字符串null

        StringBuffer sb1 = new StringBuffer(str); // 拋異常 NullPointerException
        System.out.println(sb1);
    }