// ... 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的,可不可以通过过某种方式修改呢?答案是反射。在*上有这样一段修改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] *, Is a Java string really immutable?
[5] Programcreek, Why String is immutable in Java ?