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