【JDK源码分析】String的存储区与不可变性

// ... literals are interned by the compiler 
// and thus refer to the same object
String s1 = "abcd";
String s2 = "abcd";
s1 == s2; // --> true 

// ... These two have the same value
// but they are not the same object
String s1 = new String("abcd");
String s2 = new String("abcd");
s1 == s2; // --> false 

看上面一段代码，我们会发生疑惑：为什么通过字符串常量实例化的String类型对象是一样的，而通过new所创建String对象却不一样呢？且看下面分解。

1. 数据存储区

String是一个比较特殊的类，除了new之外，还可以用字面常量来定义。为了弄清楚这二者间的区别，首先我们得明白JVM运行时数据存储区，这里有一张图对此有清晰的描述：

非共享数据存储区

非共享数据存储区是在线程启动时被创建的，包括：

• 程序计数器（program counter register）控制线程的执行；
• 栈（JVM Stack, Native Method Stack）存储方法调用与对象的引用等。

共享数据存储区

该存储区被所有线程所共享，可分为：

• 堆（Heap）存储所有的Java对象，当执行new对象时，会在堆里自动进行内存分配。
• 方法区（Method Area）存储常量池（run-time constant pool）、字段与方法的数据、方法与构造器的代码。

2. 两种实例化

实例化String对象：

public class StringLiterals {
    public static void main(String[] args) {
        String one = "Test";
        String two = "Test";
        String three = "T" + "e" + "s" + "t";
        String four = new String("Test");
    }
}

javap -c StringLiterals反编译生成字节码，我们选取感兴趣的部分如下：

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String Test
       2: astore_1
       3: ldc           #2                  // String Test
       5: astore_2
       6: ldc           #2                  // String Test
       8: astore_3
       9: new           #3                  // class java/lang/String
      12: dup
      13: ldc           #2                  // String Test
      15: invokespecial #4                  // Method java/lang/String."<init>": (Ljava/lang/String;)V
      18: astore        4
      20: return
}

ldc #2表示从常量池中取#2的常量入栈，astore_1表示将引用存在本地变量1中。因此，我们可以看出：对象one、two、three均指向常量池中的字面常量"Test"；对象four是在堆中new的新对象；如下图所示：

总结如下：

• 当用字面常量实例化时，String对象存储在常量池；
• 当用new实例化时，String对象存储在堆中；

操作符==比较的是对象的引用，当其指向的对象不同时，则为false。因此，开篇中的代码会出现通过new所创建String对象不一样。

3. 不可变String

String源码

JDK7的String类：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0
}

String类被声明为final，不可以被继承，所有的方法隐式地指定为final，因为无法被覆盖。字段char value[]表示String类所对应的字符串，被声明为private final；即初始化后不能被修改。常用的new实例化对象String s1 = new String("abcd");的构造器：

public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}

只需将value与hash的字段值进行传递即可。

不可变性

所谓不可变性（immutability）指类不可以通过常用的API被修改。为了更好地理解不可变性，我们先来看《Thinking in Java》中的一段代码：

//: operators/Assignment.java
// Assignment with objects is a bit tricky.
import static net.mindview.util.Print.*;

class Tank {
  int level;
}   

public class Assignment {
  public static void main(String[] args) {
    Tank t1 = new Tank();
    Tank t2 = new Tank();
    t1.level = 9;
    t2.level = 47;
    print("1: t1.level: " + t1.level +
          ", t2.level: " + t2.level);
    t1 = t2;
    print("2: t1.level: " + t1.level +
          ", t2.level: " + t2.level);
    t1.level = 27;
    print("3: t1.level: " + t1.level +
          ", t2.level: " + t2.level);
  }
} /* Output:
1: t1.level: 9, t2.level: 47
2: t1.level: 47, t2.level: 47
3: t1.level: 27, t2.level: 27
*///:~

上述代码中，在赋值操作t1 = t2;之后，t1、t2包含的是相同的引用，指向同一个对象。因此对t1对象的修改，直接影响了t2对象的字段改变。显然，Tank类是可变的。

也许，有人会说s = s.concat("ef");不是修改了对象s么？而事实上，我们去看concat的实现，会发现其返回的是新String对象（return new String(buf, true);）；改变的只是s1引用所指向的对象，如下图所示：

4. 反射

String的value字段是final的，可不可以通过过某种方式修改呢？答案是反射。在stackoverflow上有这样一段修改value字段的代码：

String s1 = "Hello World";  
String s2 = "Hello World";  
String s3 = s1.substring(6);  
System.out.println(s1); // Hello World  
System.out.println(s2); // Hello World  
System.out.println(s3); // World  

Field field = String.class.getDeclaredField("value");  
field.setAccessible(true);  
char[] value = (char[])field.get(s1);  
value[6] = 'J';  
value[7] = 'a';  
value[8] = 'v';  
value[9] = 'a';  
value[10] = '!';  

System.out.println(s1); // Hello Java!  
System.out.println(s2); // Hello Java!  
System.out.println(s3); // World  

在上述代码中，为什么对象s2的值也会被修改，而对象s3的值却不会呢？根据前面的介绍，s1与s2指向同一个对象；所以当s1被修改后，s2也会对应地被修改。至于s3对象为什么不会？我们来看看substring()的实现：

public String substring(int beginIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    int subLen = value.length - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

当beginIndex不为0时，返回的是new的String对象；当beginIndex为0时，返回的是原对象本身。如果将String s3 = s1.substring(6);改为String s3 = s1.substring(0);，那么对象s3也会被修改了。

如果仔细看java.lang.String.java，我们会发现：当需要改变字符串内容时，String类的方法返回的是新String对象；如果没有改变，String类的方法则返回原对象引用。这节省了存储空间与额外的开销。

5. 参考资料

[1] Programcreek, JVM Run-Time Data Areas.
[2] Corey McGlone, Looking "Under the Hood" with javap.
[3] Programcreek, Diagram to show Java String’s Immutability.
[4] Stackoverflow, Is a Java string really immutable?
[5] Programcreek, Why String is immutable in Java ?