String類

java.lang.String類代表字串

Java 程式中的所有字串字面值（如 "abc" ）都作為此類的例項實現。

特點

• 字串的內容不可變！！
• 因為 String 物件是不可變的，所以可以共享。
• 字串效果上相當於是char[]字元陣列，但底層原理是byte[]位元組陣列（JDK9）

構造方法

package com;

public class StringTest {
    public static void main(String[] args) {
        // 常見建立字串的3+1的方式
        String str1 = new String();
        System.out.println("第一種無參構造方法建立字串："+str1);

        char[] array = {‘A‘,‘B‘,‘C‘};
        String str2 = new String(array);
        System.out.println("第二種傳入字元陣列建立字串："+str2);

        byte[] array2 = {65,66,67};
        String str3 = new String(array2);
        System.out.println("第三種傳入位元組陣列建立字串："+str3);

        String str = "hello";
        System.out.println("直接建立字串:"+str);
    }
}

注意

• 直接用雙引號建立的字串，JVM會自動將它new成字串物件

字串常量池

程式當中直接寫上雙引號的字串，存在字串常量池中

package com;

public class StringPool {
    public static void main(String[] args) {
        String str1 = "123";
        String str2 = "123";

        char[] charArray = {‘1‘,‘2‘,‘3‘};
        String str3 = new String(charArray);

        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str2 == str3);
    }
}

結果

true
false
false

示意圖

注意

• 對於基本型別 --> 兩個等號是比較【數值】是否相等
• 對於引用型別 --> 兩個等號是比較【地址值】是否相等
• 直接用雙引號建立的字串會先到常量池看存不存在，字串共享
• 使用new建立的字串與常量池無關，會在堆中開闢新的空間

常用方法

查詢方法

indexOf 和 lastIndexOf的多種過載方法

轉換方法

?

其他方法

案例

package com;

/**
 * equals方法的使用
 * equalsIgnoreCase 忽略大小寫的比較
 */
public class StringEquals {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] array = {‘H‘,‘e‘,‘l‘,‘o‘};
        String str3 = new String(array);

        System.out.println(str1.equals(str3));
        System.out.println(str2.equals(str3));
        System.out.println(str3.equals("Hello"));
        System.out.println("Hello".equals(str3));
        // 推薦常量字串寫在前面。變數寫前面可能會出現空指標異常

        System.out.println("=============");
        String str4 = "hello";
        System.out.println(str3.equals(str4));
        // 忽略大小寫
        System.out.println(str3.equalsIgnoreCase(str4));

    }
}

注意事項

• 任何物件都可以用Object進行接收
• equals方法具有對稱性！即 a.equals(b) 和 b.equals(a)效果一樣
• 如果一個常量和一個變數比較，推薦把常量字串寫在前面！

package com;

/**
 * length() 返回長度
 * concat 拼接
 * charAt 獲取指定索引位置的單個字元
 * indexOf 查詢首次出現的索引位置，無返回-1
 */
public class StringGet {
    public static void main(String[] args) {
        System.out.println("Hello world".length());

        // 拼接字串 （String不可變！！）
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1); // 原封不動
        System.out.println(str2); // 原封不動
        System.out.println(str3); // 新的字串

        // 獲取指定索引位置的單個字元
        System.out.println("Hello在0號索引位置的字元是："+"Hello".charAt(0));
        System.out.println("Hello在4號索引位置的字元是："+"Hello".charAt(4));

        // 查詢引數字串在原字串當中出現的第一次索引位置
        System.out.println();
        String strA = "Hello World Hello1";
        System.out.println(strA.indexOf("hello")); // 查不到返回 -1
        System.out.println(strA.indexOf("Hello1"));// 首次出現的索引

    }
}

package com;

/**
 * 字元的擷取方法
 * substring(int index)
 * substring(int begin,int end) 【b,n)左閉右開
 *
 */
public class StringSub {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        // 字串不能發生改變，每當對原值操作就是生產新的字串
        System.out.println(str1);
        System.out.println(str2);

        String str3 = str1.substring(4,7);
        // 左閉右開
        System.out.println(str3);

    }
}

package com;

/**
 * 轉換相關的方法
 * toCharArray[] 將當前字串拆分為字元陣列
 * getBytes() 獲得當前字串的底層位元組陣列
 * replace替換
 * valueOf 轉換成字串
 *
 */
public class StringConvert {
    public static void main(String[] args) {
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);
        System.out.println(chars.length);
        System.out.println("===========");

        // IO經常用的位元組流寫入
        byte[] bytes = "abc".getBytes();
        for (byte b : bytes) {
            System.out.print(b + "\t");
        }
        System.out.println();

        String str1 = "Hi boy";
        String str2 = str1.replace("boy","girl");
        System.out.println(str1);
        System.out.println(str2);
        System.out.println("===========");
        
        // 八大基本資料型別轉換為字串
        int num = 123;
        double d = 999.999;
        boolean b = false;
        char ch = ‘a‘;

        System.out.println(String.valueOf(num));
        System.out.println(String.valueOf(d));
        System.out.println(String.valueOf(b));
        System.out.println(String.valueOf(ch));
        
    }
}

package com;

/**
 * 分割方法split
 * String[] split(String regex)
 * split 的引數 regex是一個正則表示式
 * 英文句點“.” 寫成“\\.”
 */
public class StringSplit {
    public static void main(String[] args) {
        String str1 = "1,2,3,4,5";
        System.out.println(str1);
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        System.out.println();

        // 特殊！！使用英文句號時（.） 需要加兩個反斜槓
        String str2 = "x.y.z";
        //String[] array2 = str2.split("."); // 直接用英文點不行
        String[] array2 = str2.split("\\.");
        System.out.println("長度為：" + array2.length);
        for (String s : array2) {
            System.out.print(s + "\t");
        }

    }
}

練習

1. 定義一個方法，吧陣列{1,3}按指定格式拼接成一個字串。格式參照如下；[word1#word2$word3]

package com.practise;

/**
 * 定義一個方法，吧陣列{1,3}按指定格式拼接成一個字串。
 * 格式參照如下；[word1#word2$word3]
 */
public class StringPractise {
    public static void main(String[] args) {
        int[] nums = {1,3};
        System.out.println(fromArrayToString(nums));
    }

    public static String fromArrayToString(int[] array) {
        String result = "[";
        for (int i = 0; i < array.length; i++) {
            if (i != array.length - 1) {
                result += "word" + array[i] + "#";
            } else {
                result += "word" + array[i];
            }
        }
        result += "]";
        return result;
    }
}

2. 鍵盤輸入一個字串，並且統計其中各種字元出現的次數。

   • 種類有：大寫字母、小寫字母、數字、其他

   package com.practise;
   
   import java.util.Scanner;
   
   /**
    * 鍵盤輸入一個字串，並且統計其中各種字元出現的次數。
    * 種類有：大寫字母、小寫字母、數字、其他
    */
   public class StringPractise2 {
       public static void main(String[] args) {
           Scanner sc = new Scanner(System.in);
           System.out.print("請輸入一個字串：");
           String str = sc.nextLine();
           char[] chars = str.toCharArray();
           int[] count = {0,};
           for (char c : chars) {
               if (c >= ‘A‘ && c <= ‘Z‘) {
                   count[0]++;
               } else if (c >= ‘a‘ && c <= ‘z‘) {
                   count[1]++;
               } else if (c >= ‘0‘ && c <= ‘9‘) {
                   count[2]++;
               } else {
                   count[3]++;
               }
           }
   
           System.out.print("大寫字母、小寫字母、數字、其他依次出現次數：");
           for (int i : count) {
               System.out.print(i + "\t");
           }
       }
   
   }
   
   

StringBuilder類

字串拼接問題

由於String類的物件內容不可改變，所以每當進行字串拼接時，總是會在記憶體中建立一個新的物件。例如：

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

在API中對String類有這樣的描述：字串是常量，它們的值在建立後不能被更改。

根據這句話分析我們的程式碼，其實總共產生了三個字串，即"Hello"、"World"和"HelloWorld"。

引用變數s首先指向Hello物件，最終指向拼接出來的新字串物件，即HelloWord 。

由此可知，如果對字串進行拼接操作，每次拼接，都會構建一個新的String物件，既耗時，又浪費空間。

為了解決這一問題，可以使用java.lang.StringBuilder類。

StringBuilder概述

查閱java.lang.StringBuilder的API，StringBuilder又稱為可變字元序列，它是一個類似於 String 的字串緩衝區，

通過某些方法呼叫可以改變該序列的長度和內容。

原來StringBuilder是個字串的緩衝區，即它是一個容器，容器中可以裝很多字串。並且能夠對其中的字串進行各種操作。

它的內部擁有一個數組用來存放字串內容，進行字串拼接時，直接在陣列中加入新內容。

StringBuilder會自動維護陣列的擴容。原理如下圖所示：(預設16字元空間，超過自動擴充)

構造方法

根據StringBuilder的API文件，常用構造方法有2個：

• public StringBuilder()：構造一個空的StringBuilder容器。
• public StringBuilder(String str)：構造一個StringBuilder容器，並將字串新增進去。

package com;

/**
 * 字串緩衝區，可以提高字串的效率
 */
public class StringBuilderTest {
    public static void main(String[] args) {
        // 無參構造
        StringBuilder sb = new StringBuilder();
        System.out.println(sb);
        System.out.println(sb.length());

        // 構造一個字串生成器，並初始化為指定的字串內容。
        StringBuilder sb2 = new StringBuilder("Hello");
        System.out.println(sb2);
    }
}

常用方法

StringBuilder常用的方法有2個：

• public StringBuilder append(...)：新增任意型別資料的字串形式，並返回當前物件自身。
• public String toString()：將當前StringBuilder物件轉換為String物件。

append方法

append方法具有多種過載形式，可以接收任意型別的引數。任何資料作為引數都會將對應的字串內容新增到StringBuilder中。例如：

package com;

/**
 * 常用方法
 * append 新增任意型別資料的字串形式，並返回當前物件自身
 * 可鏈式新增！sb.append("hello").append("world");
 */
public class StringBuilderTest {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        System.out.println("呼叫append方法前，sb的值：" + sb);
        sb.append("world");
        System.out.println("呼叫append方法後，sb的值：" + sb);


        StringBuilder builder = new StringBuilder();
        // 可以新增 任何型別
        builder.append("hello ");
        builder.append("world ");
        builder.append(true);
        builder.append(100);
        // 鏈式程式設計
        builder.append("\n---------\n").append("world ").append(true).append(100);
        System.out.println("builder:"+builder);
    }
}

備註：StringBuilder已經覆蓋重寫了Object當中的toString方法。

toString方法

通過toString方法，StringBuilder物件將會轉換為不可變的String物件。如：

package com;

/**
 * StringBuilder 和 String 之間的轉換
 * String -> StringBuilder  ： new StringBuilder("字串")
 * StringBuilder -> String  ： toString()
 */
public class StringBuilderTest2 {
    public static void main(String[] args) {
        String str = "hello";
        System.out.println(str);

        StringBuilder sb = new StringBuilder(str);
        sb.append(" world");
        System.out.println(sb);

        String s = sb.toString();
        System.out.println(s);

    }
}

方法自查