在内存中到底建立几个String对象

 

下面这段代码建立了几个对象？

String a="ab"+"cd";

紧接着这段代码以后的每每是这个问题，那就是这行代码究竟建立了几个
String对象呢？相信你们对这道题并不陌生，答案也是众所周知的，2个。接下来咱们就从这道题展开，一块儿回顾一下与建立String对象相关的一些JAVA知识。   
咱们能够把上面这行代码分红String str、=、"abc"和new String()四部分来看待。String str只是定义了一个名为str的String类型的变量，所以它并无建立对象；=是对变量str进行初始化，将某个对象的引用（或者叫句柄）赋值给它，显然也没有建立对象；如今只剩下new String("abc")了。那么，new String("abc")为何又能被当作"abc"和new String()呢？咱们来看一下被咱们调用了的String的构造器：

public String(String original) {  
      //other code ...   
 }

你们都知道，咱们经常使用的建立一个类的实例（对象）的方法有如下两种：  

1. 使用new建立对象。  
2. 调用Class类的newInstance方法，利用反射机制建立对象。   
咱们正是使用new调用了String类的上面那个构造器方法建立了一个对象，并将它的引用赋值给了str变量。同时咱们注意到，被调用的构造器方法接受的参数也是一个String对象，这个对象正是"abc"。由此咱们又要引入另一种建立String对象的方式的讨论——引号内包含文本。   

这种方式是String特有的，而且它与new的方式存在很大区别。

String str ="abc";

上面这行代码建立了一个String对象

String  a = "abc";

String b = "abc";

上面这两行代码也建立了一个String对象

String a ="ab"+"cd";

上面这行代码仍然只建立一个String对象

答案还是一个。有点奇怪吗？说到这里，咱们就须要引入对字符串池相关知识的回顾了。   
在JAVA虚拟机（JVM）中存在着一个字符串池，其中保存着不少String对象，而且能够被共享使用，所以它提升了效率。因为String类是final的，它的值一经建立就不可改变，所以咱们不用担忧String对象共享而带来程序的混乱。字符串池由String类维护，咱们能够调用intern()方法来访问字符串池。   
咱们再回头看看String a="abc";，这行代码被执行的时候，JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的这么一个对象，它的判断依据是String类equals(Object obj)方法的返回值。若是有，则再也不建立新的对象，直接返回已存在对象的引用；若是没有，则先建立这个对象，而后把它加入到字符串池中，再将它的引用返回。所以，咱们不难理解前面三个例子中头两个例子为何是这个答案了。

对于String a = "ab"+"cd";

因为常量的值在编译的时候就被肯定了。在这里，"ab"和"cd"都是常量，所以变量a的值在编译时就能够肯定。这行代码编译后的效果等同于： 

String a ="abcd";

所以只建立了一个对象“abcd”,而且它将被保存在字符串池中。

如今问题又来了，是否是全部通过“+”链接后获得的字符串都会被添加到字符串池中呢？咱们都知道“==”能够用来比较两个变量，它有如下两种状况： 

 1. 若是比较的是两个基本类型（char，byte，short，int，long，float，double，boolean），则是判断它们的值是否相等。  
2. 若是表较的是两个对象变量，则是判断它们的引用是否指向同一个对象。

下面咱们就用“==”来作几个测试。为了便于说明，咱们把指向字符串池中已经存在的对象也视为该对象被加入了字符串池：

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   建立的对象 \"没加入\" 字符串池中");
        }
    }
}

运行结果以下：

String a = "ab";
String b = "cd";
"ab"+"cd" 建立的对象 "加入了" 字符串池中
a  +"cd" 建立的对象 "没加入" 字符串池中
"ab"+ b   建立的对象 "没加入" 字符串池中
a  + b   建立的对象 "没加入" 字符串池中

从上面的结果中咱们不难看出，只有使用引号包含文本的方式建立的String对象之间使用“+”链接产生的新对象才会被加入字符串池中。对于全部包含new方式新建对象（包括null）的“+”链接表达式，它所产生的新对象都不会被加入字符串池中，对此咱们再也不赘述。 

可是有一种状况须要引发咱们的注意。请看下面的代码： 

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的值也是固定的，它在类被编译时就已经肯定了。也就是说： 

String s=A+B;

等价于

String s="ab"+"cd";

我对上面的例子稍加改变看看会出现什么状况

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()方法，它的定义以下：

1.	public native String intern();

这是一个本地方法。在调用这个方法时，JAVA虚拟机首先检查字符串池中是否已经存在与该对象值相等对象存在，若是有则返回字符串池中对象的引用；若是没有，则先在字符串池中建立一个相同值的String对象，而后再将它的引用返回。
咱们来看这段代码：

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没被加入字符串池中，新建了对象");
        }
    }
}

运行结果：

1. 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")为何是建立了两个对象这个问题就已经至关明了了。