从字节码角度深入理解 String 常量池

直接上菜，本文环境为 jdk1.8

之前一直对字符串常量池理解不深，看了一些文章和自己一些实验整理一下。文章主要是解释了 “一段代码会创建多少个对象？” 以及 “两个字符串变量是否指向同一个地址？” 的问题。

首先 String 是一种不可变类型，和 Integer 之类的包装类型有 [-128,127] 的常量池一样，String 也有它的常量池，只不过 Integer 是在创建实例的时候就创建了这个常量池（具体实现如下），而 String 是在创建过程中新增到常量池中。

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

字符串创建的两种方式：

		String s1 = "abc"; // 1
		
        String s2 = new String("abc");// 2

这里编译之后如下：

 0 ldc #2 <abc>
 2 astore_1
 
 3 new #3 <java/lang/String>
 6 dup
 7 ldc #2 <abc>
 9 invokespecial #4 <java/lang/String.<init>>
12 astore_2

这里 ldc 简单来说就是从运行时常量池取数据，具体可以看 这个链接。

可以看出来第一句是直接指向常量池的 “abc”。第二句先创建了 String 对象，然后从常量池取出 “abc”，接着执行 init 构造方法。可以看出这里两个 “abc” 都是同一个字符串常量，引用关系如下图。

在以下代码中会看到不同的编写方式在编译后的区别

        String s3 = new String(s1 + "def"); // 3
        
        String s4 = new String("abc" + "def"); // 4

编译后如下：

 13 new #3 <java/lang/String>
 16 dup
 17 new #6 <java/lang/StringBuilder>
 20 dup
 21 invokespecial #7 <java/lang/StringBuilder.<init>>
 24 aload_1  //这里在上面出现过，表示将 s1 取出来
 25 invokevirtual #8 <java/lang/StringBuilder.append>
 28 ldc #4 <def>
 30 invokevirtual #8 <java/lang/StringBuilder.append>
 33 invokevirtual #9 <java/lang/StringBuilder.toString>
 36 invokespecial #5 <java/lang/String.<init>>
 39 astore_3
 
 40 new #3 <java/lang/String>
 43 dup
 44 ldc #10 <abcdef>
 46 invokespecial #5 <java/lang/String.<init>>
 49 astore 4

这里的 astore 和 aload 之类的是因为 Java 是一种基于栈的指令集架构，另外一种指令集架构则是基于寄存器的指令集架构。有兴趣可以查一下相关文章，这里就不展开了。

上面可以看出看第三句和第四句编译后的差别比较大，主要是因为编译为字节码时编译器会进行一定的优化，比如第四句中的 new String("abc" + "def") 会被优化为 new String("abcdef") ，所以在字节码中直接在常量池中取了 “abcdef” 这个字符串常量。所以第四句和第二句其实没有区别，都是先在常量池创建一个字符串常量，然后将 String 对象指向这个常量。

这里用第三句来解释 “一段代码会创建多少个对象？” 这个问题。首先创建了一个 String 对象，然后中间字符串的运算是通过 StringBuilder 对象完成的，所以这里还创建了一个 StringBuilder 对象，接着是在常量池创建了 “def” 对象，接着就和之前没有区别了。所以说，第三句代码中一共创建了三个对象，创建对象的个数是和常量池中的具体情况有关系的，假设 “def” 已经在常量池存在了，那么也就不会再创建一个了。

接着再来分析另一个更加复杂的：

		String s5 = new String(new String("aa")  + new String("bb"));// 5

编译后如下：

 51 new #3 <java/lang/String>
 54 dup
 55 new #6 <java/lang/StringBuilder>
 58 dup
 59 invokespecial #7 <java/lang/StringBuilder.<init>>
 62 new #3 <java/lang/String>
 65 dup
 66 ldc #11 <aa>
 68 invokespecial #5 <java/lang/String.<init>>
 71 invokevirtual #8 <java/lang/StringBuilder.append>
 74 new #3 <java/lang/String>
 77 dup
 78 ldc #12 <bb>
 80 invokespecial #5 <java/lang/String.<init>>
 83 invokevirtual #8 <java/lang/StringBuilder.append>
 86 invokevirtual #9 <java/lang/StringBuilder.toString>
 89 invokespecial #5 <java/lang/String.<init>>
 92 astore 5

这里首先会创建一个最外层的 String 对象，然后是一个 StringBuilder 对象，接着是中间两个 String 对象和对应的 “aa” “bb”，也就是 6 个对象，当然这是最多的情况，最少情况是 “aa” “bb” 都已经存在了，也就是 4 个对象。

下面主要解决 “两个字符串变量是否指向同一个地址？”

主要的疑问是在调用 intern 方法后比较，intern 方法有两种情况。第一种，常量池中存在那么 String s6 = s4.intern(); 指向常量池中的常量，如下第一个图；第二种，如果常量池中不存在，那么会在常量池中生成一个对应的常量，但是这个常量存的是一个指向调用 intern 函数对象的指针，如下第二个图。

主要有两种情况:

1. 第一种情况

        //String s1 = "abc";
        //String s3 = new String(s1 + "def");
        String s4 = new String("abc" + "def");
        String s6 = s4.intern();
        String s5 = "abcdef";
        System.out.println(s4 == s5 ); // false

这种情况显然不同。

2. 第二种情况

        String s1 = "abc";
        String s3 = new String(s1 + "def");
        //String s4 = new String("abc" + "def");
        s3.intern();
        String s5 = "abcdef";
        System.out.println(s3 == s5 ); // true

这里创建 s3 的时候并没有在常量池创建对应的 “abcdef”，所以调用 intern 函数的时候只是在常量池创建了指向堆中地址的引用。接着创建 s5 ，这时候这个变量指向了堆中的地址，所以在后面 s3 == s5 会返回 true。