创建了几个 String 对象?

我们首先来看一段代码:
Java 代码 :
String str=new String("abc");
紧接着这段代码之后的往往是这个问题,那就是这行代码究竟创建了几个 String 对象呢? 相信大家对这道题并不陌生,答案也是众所周知的,2 个。 接下来我们就从这道题展开,一起回顾一下与创建 String 对象相关的一些 JAVA 知识。 我们可以把上面这行代码分成 String str、=、"abc"和 new String()四部分来看待。 String str 只是定义了一个名为 str 的 String 类型的变量,因此它并没有创建对象; =是对变量 str 进行初始化,将某个对象的引用(或者叫句柄)赋值给它,显然也没有创建对象; 现在只剩下 new String("abc")了。那么,new String("abc")为什么又能被看成"abc"和 new String()呢? 我们来看一下被我们调用了的 String 的构造器: Java 代码
public String(String original) {
	//other code ...
}
大家都知道,我们常用的创建一个类的实例(对象)的方法有以下两种: 1. 使用 new 创建对象。 2. 调用 Class 类的 newInstance 方法,利用反射机制创建对象。 我们正是使用 new 调用了 String 类的上面那个构造器方法创建了一个对象,并将它的引用赋值给了 str 变量。 同时我们注意到,被调用的构造器方法接受的参数也是一个 String 对象,这个对象正是"abc"。 由此我们又要引入另外一种创建 String 对象的方式的讨论——引号内包含文本。 这种方式是 String 特有的,并且它与 new 的方式存在很大区别。 Java 代码
String str="abc";
毫无疑问,这行代码创建了一个 String 对象。 Java 代码
String a="abc";
String b="abc";
那这里呢?答案还是一个。 Java 代码
String a="ab"+"cd";
再看看这里呢?答案仍是一个。有点奇怪吗?说到这里,我们就需要引入对字符串池相关知识的回顾了。 在 JAVA 虚拟机(JVM)中存在着一个字符串池,其中保存着很多 String 对象,并且可以被共享使用,因此它提高了效率。 由于 String 类是 final 的,它的值一经创建就不可改变,因此我们不用担心 String 对象共享而带来程序的混乱。 字符串池由 String 类维护,我们可以调用intern()方法来访问字符串池。 我们再回头看看 String a="abc";这行代码被执行的时候,JAVA 虚拟机首先在字符串池中查找是否已经存在了值为"abc"的这么一个对象, 它的判断依据是 String 类 equals(Object obj)方法的返回值。如果有,则不再创建新的对象,直接返回已存在对象的引用; 如果没有,则先创建这个对象,然后把它加入到字符串池中,再将它的引用返回。 因此,我们不难理解前面三个例子中头两个例子为什么是这个答案了。 对于第三个例子: Java 代码
String a="ab"+"cd";
由于常量的值在编译的时候就被确定了。在这里,"ab"和"cd"都是常量,因此变量 a 的值在编译时就可以确定。 这行代码编译后的效果等同于: Java 代码
String a="abcd";
因此这里只创建了一个对象"abcd",并且它被保存在字符串池里了。 现在问题又来了,是不是所有经过“+”连接后得到的字符串都会被添加到字符串池中呢? 我们都知道“==”可以用来比较两个变量,它有以下两种情况: 1. 如果比较的是两个基本类型(char,byte,short,int,long,float,double,boolean), 则是判断它们的值是否相等。 2. 如果表较的是两个对象变量,则是判断它们的引用是否指向同一个对象。 下面我们就用“==”来做几个测试。为了便于说明,我们把指向字符串池中已经存在的对象也视为该对象被加入了字符串池: Java 代码
public class StringTest {
	public static void main(String[] args) {
		String a = "ab";// 创建了一个对象,并加入字符串池中
		System.out.println("String a = \"ab\";");
		String b = "cd";// 创建了一个对象,并加入字符串池中
		System.out.println("String b = \"cd\";");
		String c = "abcd";// 创建了一个对象,并加入字符串池中
		String d = "ab" + "cd";
		// 如果 d 和 c 指向了同一个对象,则说明 d 也被加入了字符串池
		if (d == c) {
			System.out.println("\"ab\"+\"cd\" 创建的对象 \"加入了\" 字符串池中");
		}
		// 如果 d 和 c 没有指向了同一个对象,则说明 d 没有被加入字符串池
		else {
			System.out.println("\"ab\"+\"cd\" 创建的对象 \"没加入\" 字符串池中");
		}
		String e = a + "cd";
		// 如果 e 和 c 指向了同一个对象,则说明 e 也被加入了字符串池
		if (e == c) {
			System.out.println(" a +\"cd\" 创建的对象 \"加入了\" 字符串池中");
		}
		// 如果 e 和 c 没有指向了同一个对象,则说明 e 没有被加入字符串池
		else {
			System.out.println(" a +\"cd\" 创建的对象 \"没加入\" 字符串池中");
		}
		String f = "ab" + b;
		// 如果 f 和 c 指向了同一个对象,则说明 f 也被加入了字符串池
		if (f == c) {
			System.out.println("\"ab\"+ b 创建的对象 \"加入了\" 字符串池中");
		}
		// 如果 f 和 c 没有指向了同一个对象,则说明 f 没有被加入字符串池
		else {
			System.out.println("\"ab\"+ b 创建的对象 \"没加入\" 字符串池中");
		}
		String g = a + b;
		// 如果 g 和 c 指向了同一个对象,则说明 g 也被加入了字符串池
		if (g == c) {
			System.out.println(" a + b 创建的对象 \"加入了\" 字符串池中");
		}
		// 如果 g 和 c 没有指向了同一个对象,则说明 g 没有被加入字符串池
		else {
			System.out.println(" a + b 创建的对象 \"没加入\" 字符串池中");
		}
	}
}
运行结果如下: 1. String a = "ab"; 2. String b = "cd"; 3. "ab"+"cd" 创建的对象 "加入了" 字符串池中 4. a +"cd" 创建的对象 "没加入" 字符串池中 5. "ab"+ b 创建的对象 "没加入" 字符串池中 6. a + b 创建的对象 "没加入" 字符串池中 从上面的结果中我们不难看出,只有使用引号包含文本的方式创建的 String 对象之间使用“+”连接产生的新对象才会被加入字符串池中。 对于所有包含 new 方式新建对象(包括 null)的“+”连接表达式,它所产生的新对象都不会被加入字符串池中,对此我们不再赘述。 但是有一种情况需要引起我们的注意。请看下面的代码: Java 代码
public class StringStaticTest {
	// 常量 A
	public static final String A = "ab";
	// 常量 B
	public static final String B = "cd";

	public static void main(String[] args) {
		// 将两个常量用+连接对 s 进行初始化
		String s = A + B;
		String t = "abcd";
		if (s == t) {
			System.out.println("s 等于 t,它们是同一个对象");
		} else {
			System.out.println("s 不等于 t,它们不是同一个对象");
		}
	}
}
这段代码的运行结果如下: • s 等于 t,它们是同一个对象 这又是为什么呢?原因是这样的,对于常量来讲,它的值是固定的,因此在编译期就能被确定了,而变量的值只有到运行时才能被确定, 因为这个变量可以被不同的方法调用,从而可能引起值的改变。在上面的例子中,A 和 B 都是常量,值是固定的,因此 s 的值也是固定的, 它在类被编译时就已经确定了。也就是说: Java 代码
String s=A+B;
等同于: Java 代码
String s="ab"+"cd";
我对上面的例子稍加改变看看会出现什么情况: Java 代码
public class StringStaticTest {
	// 常量 A
	public static final String A;
	// 常量 B
	public static final String B;
	static {
		A = "ab";
		B = "cd";
	}

	public static void main(String[] args) {
		// 将两个常量用+连接对 s 进行初始化
		String s = A + B;
		String t = "abcd";
		if (s == t) {
			System.out.println("s 等于 t,它们是同一个对象");
		} else {
			System.out.println("s 不等于 t,它们不是同一个对象");
		}
	}
}
它的运行结果是这样: • s 不等于 t,它们不是同一个对象 只是做了一点改动,结果就和刚刚的例子恰好相反。我 们再来分析一下。A 和 B 虽然被定义为常量(只能被赋值一次),但是它们都没有马上被赋值。 在运算出 s 的值之前,他们何时被赋值,以及被赋予什么样的值,都是个变数。 因此 A 和 B 在被赋值之前,性质类似于一个变量。那么 s 就不能在编译期被确定,而只能在运行时被创建了。 由于字符串池中对象的共享能够带来效率的提高,因此我们提倡大家用引号包含文本的方式来创建 String 对象, 实际上这也是我们在编程中常采用的。 接下来我们再来看看 intern()方法,它的定义如下: Java 代码
public native String intern();
这是一个本地方法。 在调用这个方法时,JAVA 虚拟机首先检查字符串池中是否已经存在与该对象值相等对象存在,如果有则返回字符串池中对象的引用; 如果没有,则先在字符串池中创建一个相同值的 String 对象,然后再将它的引用返回。 我们来看这段代码: Java 代码
public class StringInternTest {
	public static void main(String[] args) {
		// 使用 char 数组来初始化 a,避免在 a 被创建之前字符串池中已经存在了值为"abcd"的对象
		String a = new String(new char[] { 'a', 'b', 'c', 'd' });
		String b = a.intern();
		if (b == a) {
			System.out.println("b 被加入了字符串池中,没有新建对象");
		} else {
			System.out.println("b 没被加入字符串池中,新建了对象");
		}
	}
}
运行结果: • b 没被加入字符串池中,新建了对象 如果 String 类的 intern()方法在没有找到相同值的对象时,是把当前对象加入字符串池中, 然后返回它的引用的话,那么 b 和 a 指向的就是同一个对象; 否则 b 指向的对象就是 JAVA 虚拟机在字符串池中新建的,只是它的值与 a 相同罢了。 上面这段代码的运行结果恰恰印证了这一点。 最后我们再来说说 String 对象在 JAVA 虚拟机(JVM)中的存储,以及字符串池与堆(heap)和栈(stack)的关系。 我们首先回顾一下堆和栈的区别: • 栈(stack):主要保存基本类型(或者叫内置类型) (char、byte、short、int、long、float、double、boolean)和对象的引用,数据可以共享, 速度仅次于寄存器(register),快于堆。 • 堆(heap):用于存储对象。 我们查看 String 类的源码就会发现,它有一个 value 属性,保存着 String 对象的值,类型是char[],这也正说明了字符串就是字符的序列。 当执行 String a="abc";时,JAVA 虚拟机会在栈中创建三个 char 型的值'a'、'b'和'c',然后在堆中创建一个 String 对象, 它的值(value)是刚才在栈中创建的三个 char 型值组成的数组{'a','b','c'},最后这个新创建的 String 对象会被添加到字符串池中。 如果我们接着执行 String b=new String("abc");代码,由于"abc"已经被创建并保存于字符串池中, 因此 JAVA 虚拟机只会在堆中新创建一个 String 对象, 但是它的值(value)是共享前一行代码执行时在栈中创建的三个 char 型值值'a'、'b'和'c'。 说到这里,我们对于篇首提出的 String str=new String("abc")为什么是创建了两个对象这个问题就已经相当明了了。


联系我们 | 友情链接