字符串常量池及基础类型常量池

字符串常量池

作为最基础的数据类型，字符串的分配以和其他对象一样，需要大量的内存。大量频繁的创建字符串会消耗大量的时间和空间，极大的影响程序性能。JVM为了减少内存消耗，做了一下优化。

• 开辟了一个字符串常量池（1.6及之前版本在永久代，1.7之后放到了堆内存）
• 创建字符串常量时首先查，字符串常量池中是否存在，存在返回引用实例，不存在实例化该字符串放到池子中

三种字符串操作（1.7及之后版本）

（1）直接赋值

String s = "Seventeen"; 

这种方式创建的字符串只会在字符串常量池中。

• 创建s对象的时候，JVM使用"Seventeen"这个字面量，先去字符串常量池中通过equals(key)方法判断字符串常量池中是否存在。
• 如果存在直接返回引用实例。
• 不存在则会在池子中创建一个新的对象，再返回引用。

（2）new String()

String s1 = new String("Seventeen");  // s1指向内堆存中的对象引用

 new 对象方式创建字符串，会保证字符串常量池和堆内存中都有这个对象，没有就创建，最后返回堆内存中的对象引用。

• JVM使用"Seventeen"这个字面量，先去字符串常量池中通过equals(key)方法判断字符串常量池中是否存在。
• 如果存在，直接在堆内存中创建个对象，返回堆内存的对象引用。
• 如果不存在，先在字符串常量池中创建对象，然后在堆内存中创建一个对象，最后返回堆内存中的对象引用。

（3）intern方法

public class Test {
    public static void main(String[] args) {
        String s1 =new String("Seventeen");
        String s2 = s1.intern();
        System.out.println(s1 == s2);
    }
}

 

 intern方法是一个native方法，当时用intern方法时，使用equals方法比较，如果字符串常量池中存在此对象的字符串，则返回池子中的字符串。否则将当前引用指向堆内存中s1对象的引用。（jdk1.6之前需要将当前s1复制到字符串常量池）。

字符串常量池位置

• Jdk1.6及之前： 有永久代, 运行时常量池在永久代，运行时常量池包含字符串常量池
• Jdk1.7：有永久代，但已经逐步“去永久代”，字符串常量池从永久代里的运行时常量池分离到堆里
• Jdk1.8及之后： 无永久代，运行时常量池在元空间，字符串常量池里依然在堆里

/**
 * 模拟使用大量String常量导致内存溢出
 * jdk6：-Xms5M -Xmx5M -XX:PermSize=5M -XX:MaxPermSize=5M  
 * jdk8：-Xms5M -Xmx5M -XX:MetaspaceSize=5M -XX:MaxMetaspaceSize=5M
 */
public class RuntimeConstantPoolOOM{
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000000; i++) {
            String str = String.valueOf(i).intern();
            list.add(str);
        }
    }
}

运行结果：
jdk8：Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
jdk6：Exception in thread "main" java.lang.OutOfMemoryError: PermGen space

 

运行结果为：jdk6版本内存溢出在永久代（方法区），jdk8内存溢出在堆内存。

结论：jdk6字符串常量池在永久代，jdk8字符串常量池在堆内存（jdk1.7及已上版本字符串常量池就已经在堆内存了，此处没有1.7的验证，感兴趣的同学可自行验证）。

字符串常量池的设计原理

字符串常量池底层是hotspot的C++实现的，底层类似一个 HashTable， 保存的本质上是字符串对象的引用。

（4）常见的String引用问题：

1.以下代码输出结果和创建了几个对象？

String s1 = new String("he") + new String("llo"); 
String s2 = s1.intern();   
System.out.println(s1 == s2);

1.6版本输出结果：false，创建6个对象

1.7及以上版本，输出结果：true，创建5个对象

导致结果不一致原因是：字符串常量池脱离永久代，移入堆中，intern方法也有相应变化。

 

String s1 =new String("he")+new String("llo");其实是new StringBuild然后使用append方法追加。new对象就会在堆内存中开辟空间。

jdk1.6执行 String s1 =new String("he")+new String("llo");

① 将"he"和"llo"在字符串常量池中创建“he”和“llo”两个对象，字符串常量池在永久代内存中，所以创建的对象也在永久代内存中。

② 在堆中再创建“he”和“llo”两个对象

③ 再通过new StringBuilder().append()，在堆中创建一个对象将字符串“he”和“llo”进行追加拼接

执行String s2 = s1.intern();

① 使用equals方法在字符串常量池中对比查找是否有“hello”

② 如果有返回当前值在池子中的引用，如果没有在字符串常量池中创建一个当前对象，返回新对象的引用

综上过程：一共创建了6个对象，s1通过new StringBuilder创建对象在堆中，s2通过intern创建对象在永久代中，地址值不一样所以s1==s2为false。

 jdk1.7及以上版本执行String s1 =new String("he")+new String("llo");

① 将"he"和"llo"在字符串常量池中创建“he”和“llo”两个对象，字符串常量池在堆内存中，所以创建的对象也在堆内存中。

② 在堆中再创建“he”和“llo”两个对象

③ 再通过new StringBuilder().append()，在堆中创建一个对象将字符串“he”和“llo”进行追加拼接

执行String s2 = s1.intern();

① 使用equals方法在字符串常量池中对比查找是否有“hello”

② 如果有返回当前值在池子中的引用，如果没有直接指向hello在堆中对象的引用，返回的也是堆中对象的引用

综上过程：一共创建了5个对象，s1通过new StringBuilder创建对象在堆中，s2通过intern将常量池中引用指向堆内存中的引用，地址值一样所以s1==s2为true。

2.以下代码执行结果是什么？

public class Test {
    public static void main(String[] args) {
        String s0="Seventeen";
        String s1="Seventeen";
        String s2="Seven" + "teen";
        System.out.println( s0==s1 );
        System.out.println( s0==s2 );
    }
}

输出结果都为true，原因如下：

使用“+”连接的字符串，在编译期就会合并在一起，查看main方法的字节码不难看出。

这三个变量其实都是在进行直接赋值，s0赋值的时候字符串常量池中没有该值，创建一个对象，当s1和s2进行赋值时，字符串常量池中已有该值直接返回该值的引用。所以三个变量其实指的是同一个内存地址，所以结果都为true。

3.以下程序的执行结果是什么？

public class Test {
    public static void main(String[] args) {
        String s0="Seventeen";
        String s1=new String("Seventeen");
        String s2="Seven" + new String("teen");
        System.out.println( s0==s1 );// false
        System.out.println( s0==s2 );// false
        System.out.println( s1==s2 );// false
    }
}

执行结果同时为false，原因如下：

通过字节码可以看出，s0是直接赋值在编译期就已确定，地址指向的是字符串常量池的引用，s1是new对象是在运行时在堆中创建的对象，s2是new StringBuilder().appen()是一个新的堆中的对象。三个地址都不一样，所以结果都为false。

 4.以下代码执行结果是什么？

  String a = "a1";
  String b = "a" + 1;
  System.out.println(a == b); // true 
  
  String a = "atrue";
  String b = "a" + "true";
  System.out.println(a == b); // true 
  
  String a = "a3.4";
  String b = "a" + 3.4;
  System.out.println(a == b); // true

执行结果同时为true，原因：a都是确认的常量值，b是通过“+”连接的常量值。b在编译期确认常量值，都是直接赋值，所以为true。

5.以下代码执行结果是什么？

public class Test {
    public static void main(String[] args) {
        String s0 = "ab";
        String s1 = "b";
        String s2 = "a" + s1;

        System.out.println(s0 == s2);
    }
}

 通过字节码能看出，s0和s1是直接赋值，而s2在编译期不能被优化，原因是由于在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的，只能在程序运行期来动态分配即new StringBuilder().append()，所以上述结果值为false。

6.以下代码执行结果是什么？

public class Test {
    public static void main(String[] args) {
        String s0 = "ab";
        final String s1 = "b";
        String s2 = "a" + s1;

        System.out.println(s0 == s2);
    }
}

和5中不同的是在s1前面加了final修饰，final修饰的变量，在编译过程中被解析为常量的本地拷贝，也是直接赋值，所以结果为true。

7.以下代码执行结果是什么？

public class Test {
    public static void main(String[] args) {
        String s0 = "ab";
        final String b = getB();
        String s1 = "a" + b;

        System.out.println(s0 == s1); // false
    }
    private static String getB()
    {
        return "b";
    }
}

它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"s0"来动态连接并分配地址为s1，故上面程序的结果为false。 

通过已上例子可以看出

① 直接赋值

String s1 = "a"+"b"+"c";

等价于

String s1 = "abc";

② 变量追加赋值

String s0 = "a";

String s1 = "b";

String s2 = "c";

String str = s0+s1+s2;

等价于

StringBuilder temp = new StringBuilder();

temp.append(a).append(b).append(c);

String s = temp.toString();

8.以下代码执行结果是什么？

public class Test {
    public static void main(String[] args) {
        // StringBuilder对象最终被GC回收，str2最终指向的地址是toString()时new String()的地址
        // 没有出现过Seventeen字面量，所以在常量池中没有Seventeen对象，通过append再toString，在堆内存中存在
        String str2 = new StringBuilder("Seven").append("teen").toString();
        // 执行intern方法时会指向，堆内存中Seventeen对象的引用，所以为  true
        System.out.println(str2 == str2.intern()); // true

        // 没有出现过java字面量，所以在常量池中没有java对象，通过append再toString，在堆内存中存在
        String str1 = new StringBuilder("ja").append("va").toString();
        // java作为关键字在JVM初始化的时候，相关类里面早就放到了常量池中，str1使用的是堆中的引用，intern使用的是常量池的引用，所以结果为false
        System.out.println(str1 == str1.intern()); // false

        // 在常量池中创建Seven对象，并且在堆内存中也会创建一个对象，s1最终指向的是堆内存中的引用
        String s1=new String("Seven");
        // 常量池中存在Seven对象，调用intern时，指向常量池中Seven对象的引用，所以结果为false
        System.out.println(s1==s1.intern()); // false

        // 与上面例子同理
        String s2=new StringBuilder("teen").toString();
        System.out.println(s2==s2.intern()); // false
    }
}

基础类型常量池

Byte,Short,Integer,Long,Character,Boolean这6中基础数据类型的包装类在堆中已实现常量池技术，另外两种浮点类型的没有实现。Byte,Short,Integer,Long,Character这5种类型包装类也只是实现-128~127之间的常量池。

public class Test {
    public static void main(String[] args) {

        Short s1 = 127;
        Short s2 = 127;
        System.out.println("Short类型直接赋值127："+(s1==s2));
        Short s3 = 128;
        Short s4 = 128;
        System.out.println("Short类型直接赋值128："+(s3==s4));
        Short s5 = -129;
        Short s6 = -129;
        System.out.println("Short类型直接赋值-129："+(s5==s6));
        Short s7 = new Short((short) 127);
        Short s8 = new Short((short) 127);
        System.out.println("Short类型new对象："+(s7 == s8));
        System.out.println("------------------------------");

        Integer i1 = 127;
        Integer i2 = 127;
        System.out.println("Integer类型直接赋值127："+(i1==i2));
        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println("Integer类型直接赋值128："+(i3==i4));
        Integer i5 = -129;
        Integer i6 = -129;
        System.out.println("Integer类型直接赋值-129："+(i5==i6));
        Integer i7 = new Integer(127);
        Integer i8 = new Integer(127);
        System.out.println("Integer类型new对象："+(i7 == i8));
        System.out.println("------------------------------");

        Long l1 = 127l;
        Long l2 = 127l;
        System.out.println("Long类型直接赋值127："+(l1==l2));
        Long l3 = 128l;
        Long l4 = 128l;
        System.out.println("Long类型直接赋值128："+(l3==l4));
        Long l5 = -129l;
        Long l6 = -129l;
        System.out.println("Long类型直接赋值128："+(l5==l6));
        Long l7 = new Long(127l);
        Long l8 = new Long(127l);
        System.out.println("Long类型new对象："+(l7 == l8));
        System.out.println("------------------------------");

        Character c1 = 127;
        Character c2 = 127;
        System.out.println("Character类型直接赋值127："+(c1==c2));
        Character c3 = 128;
        Character c4 = 128;
        System.out.println("Character类型直接赋值128："+(c3==c4));
        Character c5 = (char) -129;
        Character c6 = (char) -129;
        System.out.println("Character类型直接赋值128："+(c5==c6));
        Character c7 = new Character((char) 127);
        Character c8 = new Character((char) 127);
        System.out.println("Character类型new对象："+(c7 == c8));
        System.out.println("------------------------------");

        Boolean b1 = true;
        Boolean b2 = true;
        System.out.println("Boolean类型直接赋值"+(b1 == b2));
        System.out.println("------------------------------");

        Double d1 = 1.0;
        Double d2 = 1.0;
        System.out.println("Boolean类型直接赋值"+(d1 == d2));
    }
}

Short类型直接赋值127：true
Short类型直接赋值128：false
Short类型直接赋值-129：false
Short类型new对象：false
------------------------------
Integer类型直接赋值127：true
Integer类型直接赋值128：false
Integer类型直接赋值-129：false
Integer类型new对象：false
------------------------------
Long类型直接赋值127：true
Long类型直接赋值128：false
Long类型直接赋值128：false
Long类型new对象：false
------------------------------
Character类型直接赋值127：true
Character类型直接赋值128：false
Character类型直接赋值128：false
Character类型new对象：false
------------------------------
Boolean类型直接赋值true
------------------------------
Boolean类型直接赋值false