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));    }}

执行结果如图所示：