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 = https://www.cnblogs.com/mengd/p/new char[0];
String str1 = new String("abc"); // char[] value = https://www.cnblogs.com/mengd/p/new char[]{'a','b','c'};

StringBuffer sb1 = new StringBuffer(); // char[] value = https://www.cnblogs.com/mengd/p/new char[16];底層創建一個長度16的char型陣列
StringBuffer sb1 = new StringBuffer("abc"); // char[] value = https://www.cnblogs.com/mengd/p/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);
    }

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/142932.html

標籤：Java

上一篇：[Java] 使用ZipInputStream決議zip類檔案（jar、docx）的范例

下一篇：泛型小記