字符串常量池

概述

String在jdk8及以前内部定义了final char[] value用于存储字符串数据。JDK9时改为byte[]

为什么JDK9上会修改这个数据结构，官方说明是：大多数字符串对象只包含Latin-1(ISO-8859-1)的字符。这些字符只需要一个字节的存储空间，因此这些字符串对象的内部字符数组中有一半的空间没有被使用。 我们建议将String类的内部表示方法从UTF-16字符数组改为字节数组加编码标志域。新的String类(JDK9及其以后)将根据字符串的内容，以ISO-8859-1/Latin-1（每个字符一个字节）或UTF-16（每个字符两个字节）的方式存储字符编码。编码标志将表明使用的是哪种编码。

JDK9及其以后

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    @Stable
    private final byte[] value;
}

JDK8

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
    
	......    
}

String的内存分配

String是一种比较特殊的引用数据类型，和Java8中基本数据类型一样，为了使它们在运行过程中速度更快、更节省内存，都提供了一种常量池的概念

什么时候会放进常量池

• 直接使用双引号声明出来的String对象会直接存储在常量池中
• 我们new出来的String对象不会放进常量池，但是可以使用String提供的intern()方法放进常量池
  • intern方法：如果字符串常量池中没有对应的字符串的话，则在常量池中生成
• 字符串常量池我自己做的实验，开始是在伊甸园区，然后随着数据的的增加，可能会存放到老年代中
  • 

JDK版本问题

Java 6及以前，字符串常量池存放在方法区

Java 7将字符串常量池的位置调整到Java堆内

• 所有的字符串都保存在堆（Heap）中，和其他普通对象一样，这样可以让你在进行调优应用时仅需要调整堆大小就可以了。

• 字符串常量池概念原本使用得比较多，但是这个改动使得我们有足够的理由让我们重新考虑在Java 7中使用String.intern()。

• 

Java8元空间，字符串常量在堆

字符串拼接操作

• 常量与常量的拼接结果在常量池，原理是编译期优化，常量池中不会存在相同内容的变量
• 只要其中有一个是变量，结果就在堆中。变量拼接的原理是StringBuilder(JDK5.0之前是用的是StringBuffer) ​​​​​​​的append的拼接操作
  • 如果变量用 final修饰了，这个时候就代表是常量，这个时候拼接结果也在常量池
• 如果拼接的结果调用intern()方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址

举例

 public static void test1() {
      // 常量与常量的拼接结果在常量池
      // 都是常量，前端编译期会进行代码优化
      // 通过idea直接看对应的反编译的class文件，会显示 String s1 = "abc"; 说明做了代码优化
      String s1 = "a" + "b" + "c";
      String s2 = "abc"; 
      // true，有上述可知，s1和s2实际上指向字符串常量池中的同一个值
      System.out.println(s1 == s2); 
  }

public static void test5() {
    String s1 = "javaEE";
    String s2 = "hadoop";
    String s3 = "javaEEhadoop";
    String s4 = "javaEE" + "hadoop";    
    String s5 = s1 + "hadoop";
    String s6 = "javaEE" + s2;
    String s7 = s1 + s2;
    System.out.println(s3 == s4); // true 编译期优化
    System.out.println(s3 == s5); // false s1是变量，不能编译期优化
    System.out.println(s3 == s6); // false s2是变量，不能编译期优化
    System.out.println(s3 == s7); // false s1、s2都是变量
    System.out.println(s5 == s6); // false s5、s6 不同的对象实例
    System.out.println(s5 == s7); // false s5、s7 不同的对象实例
    System.out.println(s6 == s7); // false s6、s7 不同的对象实例

    String s8 = s6.intern();
    System.out.println(s3 == s8); // true intern之后，s8和s3一样，指向字符串常量池中的"javaEEhadoop"
}

//不使用final修饰，即为变量。如s3行的s1和s2，会通过new StringBuilder进行拼接
// 使用final修饰，即为常量。会在编译器进行代码优化。在实际开发中，能够使用final的，尽量使用
public void test6(){
    String s0 = "beijing";
    String s1 = "bei";
    String s2 = "jing";
    String s3 = s1 + s2;
    System.out.println(s0 == s3); // false s3指向对象实例，s0指向字符串常量池中的"beijing"
    String s7 = "shanxi";
    final String s4 = "shan";
    final String s5 = "xi";
    String s6 = s4 + s5;
    System.out.println(s6 == s7); // true s4和s5是final修饰的，编译期就能确定s6的值了
}

拼接细节：

public void test3(){
    String s1 = "a";
    String s2 = "b";
    String s3 = "ab";
    /**
     *1.new StringBuild();
     *2.append(s1);
     *3.append(s2);
     *4.toString();
    */
    String s4 = s1 + s2;
    // 结果是false
    System.out.println(s3==s4);
}

// StringBuilder 的 toString 方法
@Override
public String toString() {
// Create a copy, don't share the array
return new String(value, 0, count);
}

可以发现s1 + s2实际上是new了一个StringBuilder对象，并使用了append方法将s1和s2添加进来，最后调用了toString方法赋给s4，但是拼接后的字符串并没有存放到字符串常量池中

字符串拼接操作性能对比

String拼接方式的时间是StringBuilder.append方式的约8000倍，StringBuffer.append()方式的时间是StringBuilder.append()方式的约4倍

在实际开发中，对于需要多次或大量拼接的操作，在不考虑线程安全问题时，我们就应该尽可能使用StringBuilder进行append操作,如果考虑线程安全，可以使用 StringBuffer.append()进行拼接

StringBuilder空参构造器的初始化大小为16。那么，如果提前知道需要拼接String的个数，就应该直接使用带参构造器指定capacity，以减少扩容的次数，扩容因数

intern()的使用

当调用intern方法时，如果池子里已经包含了一个与这个String对象相等的字符串，那么池子里的字符串会被返回。否则，这个String对象被添加到池中，并返回这个String对象的引用。

由此可见，对于任何两个字符串s和t，当且仅当s.equals(t)为真时，s.intern() == t.intern()为真

intern是一个native方法，调用的是底层C的方法

注意：JDK6和JDK7及其以后得intern方法是不一样的

通过下面的例子感受一下吧

/**
 * ① String s = new String("1")
 * 创建了两个对象
 * 		堆空间中一个new对象
 * 		字符串常量池中一个字符串常量"1"（注意：此时字符串常量池中已有"1"）
 * ② s.intern()由于字符串常量池中已存在"1"
 * 
 * s  指向的是堆空间中的对象地址
 * s2 指向的是堆空间中常量池中"1"的地址
 * 所以不相等
 */
String s = new String("1");
s.intern();// 调用此方法之前，字符串常量池中已经有该"1"了，所以就不用存放到字符串常量池中
String s2 = "1";
System.out.println(s==s2); // jdk1.6 false jdk7/8 false

/*
 * ① String s3 = new String("1") + new String("1")
 * 等价于new String（"11"），但是，常量池中并不生成字符串"11"；
 *
 * ② s3.intern()
 * 	由于此时常量池中并无"11"，所以把s3中记录的对象的地址存入常量池
 *	所以s3 和 s4 指向的都是一个地址
*/
// 创建详情看 String s = new String("xxx") + new String("yyy")会创建几个对象
String s3 = new String("1") + new String("1");
// 在字符串常量池中“生成”了"11"
//		这个生成，不同版本理解是不一样的
// jdk6中在字符串常量池中创建了一个新的对象，也就有了新的地址，s4 = "11" 的时候是把新地址给了 s4，这时候两个地址就不一样了
// jdk7及其以后，并没有在常量池中创建对象，而是创建了一个指向堆空间 new String("11")的一个地址（就是s3的地址）
// s4 = "11" 的时候，是吧堆空间的那个地址给了s4，此时s3和 s4的地址是一样的，所以就是true
s3.intern();
String s4 = "11";// 使用的是上一样代码在常量池中生成的"11"
System.out.println(s3==s4); //jdk1.6 false jdk7/8 true

总结

JDK1.6中，将这个字符串对象尝试放入串池。

• 如果串池中有，则并不会放入。返回已有的串池中的对象的地址

• 如果没有，会把此对象复制一份，放入串池，并返回串池中的对象地址

JDK1.7起，将这个字符串对象尝试放入串池。

• 如果串池中有，则并不会放入。返回已有的串池中的对象的地址

• 如果没有，则会把对象的引用地址复制一份，放入串池，并返回串池中的引用地址

总结

对于程序中大量使用存在的字符串时，尤其存在很多已经重复的字符串时，使用intern()方法能够节省内存空间。

大的网站平台，需要内存中存储大量的字符串。比如社交网站，很多人都存储：北京市、海淀区等信息。这时候如果字符串都调用intern()方法，就会很明显降低内存的大小。