java中字符串String、StringBuilder、StringBuffer的常用方法

String的常用方法：

public static void main(String[] args) {
        String str = "Hello world!";
        // 獲取字符串的長度
        Integer lenth = str.length();
        
        // 返回指定字符在此字符串中第一次出現處的索引 -- 從0開始
        Integer index = str.indexOf("l");
        
        // 返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索。
        Integer index2 = str.indexOf("l", 5);
        
        // 從指定位置開始，截取到最后的字符串返回
        String substr1 = str.substring(3);
        
        // 從指定位置開始到指定位置結束，截取字符串返回
        String substr2 = str.substring(3, 9);
        
        // 返回去除字符串前后空格后的字符串
        String str2 = str.trim();
        
        // 返回指定位置的char字符
        char str3 = str.charAt(5);
        
        // 返回此字符串是否以指定的前綴開始
        boolean res1 = str.startsWith("He");
        
        // 返回此字符串是否以指定的后綴結束
        boolean res2 = str.endsWith("!");
        
        // 返回此字符串從指定的位置開始的子字符串是否以指定前綴開始
        boolean res3 = str.startsWith("world", 6);
        
        // 使用默認語言環境的規則將此 String 中的所有字符都轉換為大寫
        String str4 = str.toUpperCase();
        
        // 使用默認語言環境的規則將此 String 中的所有字符都轉換為小寫
        String str5 = str.toLowerCase();
        
        // 返回參數的字符串表示形式 -- 參數可以是其他基本類型、數組、object
        String str6 = valueOf(true);
        
        // 判斷此字符串是否匹配給定的正則表達式
        String regEx = "\\\\d{4}\\\\-\\\\d{1,2}\\\\-\\\\d{1,2}";
        boolean res4 = str.matches(regEx);

        // 以指定的字符(正則表達式)分割字符串，得到的是數組
        String[] arr1 = str.split("o");
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(i + ":" + arr1[i]);
        }
        
        // 以指定的字符(或正則表達式)分割字符串，得到的是數組，后面的參數是對於分割次數的限制，為1將不會分割，得到完整的字符串，為2時，得到第一次分割后的內容
        String[] arr2 = str.split("o", 3);
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(i + ":" + arr2[i]);
        }

        // 用於根據新的子字符串替換字符串中所有匹配的子字符串
        String str7 = str.replace("o", "c");
        
        // 用於根據新的子字符串替換字符串中所有匹配正則表達式的子字符串
        String str8 = str.replaceAll("o", "c");
        
        // 使用給定的新的子字符串替換字符串中給定正則表達式的第一個子字符串
        String str9 = str.replaceFirst("o","c");
        
        // 判斷字符串是不是空的
        boolean res5 = str.isEmpty();

    }

StringBuilder的常用方法：

public static void main(String[] args) {

        StringBuilder sb = new StringBuilder("hello");
        // 追加字符串
        sb.append("world!");
        System.out.println(sb);

        // 在指定位置開始插入字符串
        sb.insert(5, " ");
        System.out.println(sb);

        // 刪除指定位置的字符串
        sb.delete(5, 6);
        System.out.println(sb);

        // 替換指定位置的字符串
        sb.replace(5, 11, " boy!");
        System.out.println(sb);

        // 反轉字符串
        sb.reverse();
        System.out.println(sb);
    }

StringBuffer的常用方法：

public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("hello");
        // 追加字符串
        sb.append("world!");
        System.out.println(sb);

        // 在指定位置開始插入字符串
        sb.insert(5, " ");
        System.out.println(sb);

        // 替換指定位置的字符串
        sb.replace(5, 6, "boy, hello");
        System.out.println(sb);

        // 刪除指定位置的字符串
        sb.delete(6, 10);
        System.out.println(sb);

        // 反轉字符串
        sb.reverse();
        System.out.println(sb);
    }

String、StrinBuilder、StringBuffer的比較

java.lang.String、java.lang.StringBuilder、java.lang.StringBuffer都使用了final修飾，不能被繼承。

public final class String implements java.io.Serializable, Comparable<String>, CharSequence
public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence
public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable, CharSequence

StringBuffer是線程安全的，同步處理，性能稍慢。
StringBuilder是非線程安全的，並發處理，性能稍快。

String 是字符串常量，對象創建后不可變
StringBuffer、StringBuilder是字符串變量，對象創建后可變。

所以運行速度：
StringBuilder > StringBuffer > String