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