字符串相关类

String 类代表不可变的字符序列
StringBuilder 类和 StringBuffer 类代表可变字符序列。

String 类源码分析

String 类对象代表不可变的 Unicode 字符序列，因此我们可以将 String 对象称为“不可变对象”。 那什么叫做“不可变对象”呢？指的是对象内部的成员变量的值无法再改变。我们打开 String 类的源码，如图所示：

我们发现字符串内容全部存储到 value[ ]数组中，而变量 value 是 final 类型的，也就是常量(即只能被赋值一次)。 这就是“不可变对象”的典型定义方式。
我们发现在前面学习 String 的某些方法，比如：substring()是对字符串的截取操作，但本质是读取原字符串内容生成了新的字符串。测试代码如下：

【示例】String 类的简单使用

public class TestString1 {
    public static void main(String[] args) {
        String s1 = new String("abcdef");
        String s2 = s1.substring(2, 4);
        // 打印：ab199863
        System.out.println(Integer.toHexString(s1.hashCode()));
        // 打印：c61, 显然 s1 和 s2 不是同一个对象
        System.out.println(Integer.toHexString(s2.hashCode()));
    }
}

在遇到字符串常量之间的拼接时，编译器会做出优化，即在编译期间就会完成字符串的拼接。因此，在使用==进行 String 对象之间的比较时，我们要特别注意，如示例所示。

【示例】字符串常量拼接时的优化

public class TestString2 {
    public static void main(String[] args) {
        //编译器做了优化,直接在编译的时候将字符串进行拼接
        String str1 = "hello" + " java"; //相当于 str1 = "hello java";
        String str2 = "hellojava";
        System.out.println(str1 == str2); //true
        String str3 = "hello";
        String str4 = " java";
        //编译的时候不知道变量中存储的是什么,所以没办法在编译的时候优化
        String str5 = str3 + str4;
        System.out.println(str2 == str5); //false
    }
}

StringBuffer 和 StringBuilder 可变字符序列

StringBuffer 和 StringBuilder 都是可变的字符序列。

• StringBuffer 线程安全，做线程同步检查， 效率较低。
• StringBuilder 线程不安全，不做线程同步检查，因此效率较高。建议采用该类。

常用方法列表：

• 重载的 public StringBuilder append(…)方法可以为该 StringBuilder 对象添加字符序列，仍然返回自身对象。
• 方法 public StringBuilder delete(int start,int end)可以删除从 start 开始到 end-1 为止的一段字符序列，仍然返回自身对象。
• 方法 public StringBuilder deleteCharAt(int index)移除此序列指定位置上的 char，仍然返回自身对象。
• 重载的 public StringBuilder insert(…)方法可以为该 StringBuilder 对象在指定位置插入字符序列，仍然返回自身对象。
• 方法 public StringBuilder reverse()用于将字符序列逆序，仍然返回自身对象。
• 方法 public String toString() 返回此序列中数据的字符串表示形式。

和 String 类含义类似的方法：

• public int indexOf(String str)
• public int indexOf(String str,int fromIndex)
• public String substring(int start)
• public String substring(int start,int end)
• public int length()
• char charAt(int index)

不可变和可变字符序列使用陷阱

String 使用的陷阱

String 一经初始化后，就不会再改变其内容了。对 String 字符串的操作实际上是对其副本（原始拷贝）的操作，原来的字符串一点都没有改变。
比如： String s ="a"; 创建了一个字符串s = s+"b"; 实际上原来的"a"字符串对象已经丢弃了，现在又产生了另一个字符串s+"b"（也就是"ab")。
如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。
如果这样的操作放到循环中，会极大影响程序的时间和空间性能，甚至会造成服务器的崩溃。
相反，StringBuilder 和 StringBuffer 类是对原字符串本身操作的，可以对字符串进行修改而不产生副本拷贝或者产生少量的副本。因此可以在循环中使用。

【示例】String 和 StringBuilder 在字符串频繁修改时的效率测试

public class Test {
    public static void main(String[] args) {
        /**使用 String 进行字符串的拼接*/
        String str8 = "";
        long num1 = Runtime.getRuntime().freeMemory(); //获取系统剩余内存空间
        long time1 = System.currentTimeMillis(); //获取系统的当前时间
        for (int i = 0; i < 5000; i++) {
            str8 = str8 + i; //相当于产生了 5000 个对象
        }
        long num2 = Runtime.getRuntime().freeMemory();
        long time2 = System.currentTimeMillis();
        System.out.println("String 占用内存 : " + (num1 - num2));
        System.out.println("String 占用时间 : " + (time2 - time1));
        /**使用 StringBuilder 进行字符串的拼接*/
        StringBuilder sb1 = new StringBuilder("");
        long num3 = Runtime.getRuntime().freeMemory();
        long time3 = System.currentTimeMillis();
        for (int i = 0; i < 5000; i++) {
            sb1.append(i);
        }
        long num4 = Runtime.getRuntime().freeMemory();
        long time4 = System.currentTimeMillis();
        System.out.println("StringBuilder 占用内存 : " + (num3 - num4));
        System.out.println("StringBuilder 占用时间 : " + (time4 - time3));
    }
}

执行结果如图所示：