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

【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
?

作者：Treant
出处：http://www.cnblogs.com/en-heng/