深入剖析 java String

• String 地址指向详解

String s1 = "ABC";
// 最多生成一个String对象, 如果常量池中已有“ABC”对象，则不生成String对象，则直接指向该地址
String s2 = "ABC";
System.out.println(s1 == s2); // true  因为都指向常量池中的“ABC”对象

String s7 = new String("ABC");
// 至少生成一个String对象，在堆中生成一个String对象
// 如果常量池中没有“ABC”对象，jvm会在常量池中生成一个“ABC”对象, 堆中的String对象指向常量池中的"ABC"对象
System.out.println(s1 == s7); // false s7指向堆中的对象地址，s1指向常量池中的“ABC”地址

String s3 = "A" + "B" + "C"; // 编译器直接连接成“ABC”了,并存于常量池中
System.out.println(s1 == s3);  // true

String s4 = "AB";
String s5 = "C";
String s6 = s4 + s5; // 至少生成两个对象 一个String  一个StringBuilder
// 运行时 jvm 会 new StringBuild对象出来,然后进行+,相当于(new StringBuild(s4)).append(s5)
// 然后转化为String; toString()时在堆生成一个新String对象指向常量池中的“ABC”对象(如果常量池没有“ABC”对象则先生成）
System.out.println(s1 == s6); // false
// s6 指向堆中的对象地址 s1 指向常量池中“ABC”对象地址

String s11 = "A4";
String s10 = "A" + 4;   // 编译期自动优化成 "A4"
System.out.println(s10 == s11); // true

int n1 = 4;
String s12 = "A" + n1;
System.out.println(s11 == s12); // false s12 指向堆地址

随便盗了个图方便加深理解 如下：

• java “+” 连接符原理

Java语言为“+”连接符以及对象转换为字符串提供了特殊的支持，字符串对象可以使用“+”连接其他对象。其中字符串连接是通过 StringBuilder（或 StringBuffer）类及其append 方法实现的，对象转换为字符串是通过 toString 方法实现的。

/** 测试代码*/
public class Test {
    public static void main(String[] args) {
        int i = 10;
        String s = "abc";
        System.out.println(s + i);
    }
}

/ ** 反编译后 */
public static void main(java.lang.String[]);
    Code:
       0: bipush        10
       2: istore_1
       3: ldc           #2                  // String abc
       5: astore_2
       6: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       9: new           #4                  // class java/lang/StringBuilder
      12: dup
      13: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
      16: aload_2
      17: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      20: iload_1
      21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      27: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      30: return

由上可以看出，Java中使用"+"连接字符串对象时，会创建一个StringBuilder()对象，并调用append()方法将数据拼接，最后调用toString()方法返回拼接好的字符串。

使用“+”连接符时，JVM会隐式创建StringBuilder对象，这种方式在大部分情况下并不会造成效率的损失，不过在进行大量循环拼接字符串时则需要注意。

String s = "abc";
for (int i=0; i<10000; i++) {
    s += "abc";  // 反编译后相当于 s = (new StringBuilder()).append(s).append("abc").toString(); 
}

这样由于大量StringBuilder创建在堆内存中，肯定会造成效率的损失，所以在这种情况下建议在循环体外创建一个StringBuilder对象调用append()方法手动拼接,建议直接用StringBuild.append 方法替代 “+” 如下：

StringBuilder sb = new StringBuilder("abc");
for (int i = 0; i < 1000; i++) {
    sb.append("abc");
    // sb.append("abc" + i); //主要不要在参数里 拼接字符串  不然拼接时 又new StringBuilder对象了
 }
sb.toString();

与此之外还有一种特殊情况，也就是当"+"两端均为编译期确定的字符串常量时，编译器会进行相应的优化，直接将两个字符串常量拼接好，例如：

String a = "abc" + "123";

/** 反编译后*/
public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String abc123  
       2: astore_1
       3: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       6: aload_1
       7: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      10: return

• 字符串常量池
  字符串的分配和其他对象分配一样，是需要消耗高昂的时间和空间的，而且字符串使用的非常多。JVM为了提高性能和减少内存的开销，在实例化字符串的时候进行了一些优化：使用字符串常量池。每当创建字符串常量时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么就直接返回常量池中的实例引用。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中。由于String字符串的不可变性，常量池中一定不存在两个相同的字符串

/**
 * 字符串常量池中的字符串只存在一份！
 * 运行结果为true
 */
String s1 = "AB";
String s2 = "AB";
String s3 = new String("AB");
System.out.println(s1 == s2);
System.out.println(s1 == s3);

当执行String s1 = "AB"时，JVM首先会去字符串常量池中检查是否存在"AB"对象，如果不存在，则在字符串常量池中创建"AB"对象，并将"AB"对象的地址返回给s1；如果存在，则不创建任何对象，直接将字符串常量池中"AB"对象的地址返回给s1。

• 本地方法intern
  直接使用双引号声明出来的String对象会直接存储在字符串常量池中，如果不是用双引号声明的String对象，可以使用String提供的intern方法。intern 方法是一个native方法，intern方法会从字符串常量池中查询当前字符串是否存在，如果存在，就直接返回当前字符串；如果不存在就会将当前字符串放入常量池中，之后再返回,

public native String intern();

public static void main(String[] args) {
    String s1 = "AB";
    String s2 = new String("AB");
    String s3 = "A";
    String s4 = "B";
    String s5 = "A" + "B";
    String s6 = s3 + s4;
    System.out.println(s1 == s2); // false
    System.out.println(s1 == s5); // true
    System.out.println(s1 == s6); // false
    System.out.println(s1 == s6.intern());  // true
    System.out.println(s2 == s2.intern());  // false
}

解析：真正理解此题目需要清楚以下三点
1）直接使用双引号声明出来的String对象会直接存储在常量池中；
2）String对象的intern方法会得到字符串对象在常量池中对应的引用，如果常量池中没有对应的字符串，则该字符串将被添加到常量池中，然后返回常量池中字符串的引用；
3） 字符串的+操作其本质是创建了StringBuilder对象进行append操作，然后将拼接后的StringBuilder对象用toString方法处理成String对象，这一点可以用javap -c命令获得class文件对应的JVM字节码指令就可以看出来。

参考资料
https://blog.youkuaiyun.com/ifwinds/article/details/80849184