String 与 intern理解

1.

public static void main(String[] args) {    String s = new String("abc");    System.out.println(s == s.intern());}

在这个代码中，首先创建的String对象是“abc”这个string字面量，然后才是new String 这个对象，为什么？因为在编译期，“abc”就已经存在.class中的常量池中，当类加载的时候，把它从.class中加载进来，在堆中首先创建了这个“abc”字面量的对象。当所有的类加载工作完成后才去执行代码指令。关于运行时常量池中的string，保存的是这个string对象的引用，而什么决定了它应该保存哪个对象的引用呢，像上面的代码，它保存的是s这个引用还是“abc”对象的引用呢？谁先创建出对象谁的引用就会放置在常量池中，所以常量池的引用就是“abc”对象的引用。

intern方法：调用这个方法的String对象的字面量在常量池中已经存在引用，就返回常量池的引用，否则就将这个对象的引用作为这个字面量的引用。上面的例子就是：s调用intern方法，JVM就去常量池看看是否有“abc”这个字面量的引用，有就返回这个引用，也就是“abc”这个对象的引用，所以上面的打印结果就是false；

2.

public static void main(String[] args) {    String s = new StringBuilder("game ").append("over").toString();    System.out.println(s == s.intern());}

2.这个例子中s的字面量为“game over”，而在常量池中只有“game ”和“over” 两个字面量的引用，所以当s调用intern方法的时候，JVM发现常量池没有“game over”字面量引用，所以将“game over”解释为s这个引用，所以打印结果为true

3.

public static void main(String[] args) {    String str = "game over";    String s = new StringBuilder("game ").append("over").toString();    System.out.println(s == s.intern());    System.out.println(str == s.intern());}

3.这个例子中在2.的例子最前面加了

String str = "game over";

那么当s调用intern返回的就是str这个引用，所以打印就是 false ，true

4.

public static void main(String[] args) {    String s = new StringBuilder("game over").toString();    System.out.println(s == s.intern());}

而4.这个例子1.这个例子是一样的，s调用返回的是“game over”这个对象的引用，当然是不等于s，所以打印结果为false

5.

public static void main(String[] args) {    String s = new StringBuilder("jav").append("a").toString();    System.out.println(s == s.intern());}

那么5.这个例子的结果又是什么？

结果是false，因为在

new StringBuilder("jav").append("a").toString();

这句代码执行之前，在常量池中已经长在“java”这个字面量对象的引用了，stackoverflow有这个问题的讨论，

At a guess, this class is used on startup to launch the programdocjar.com/html/api/com/sun/tools/jdi/… and on line 125 there is the String literal "java" – Peter Lawrey，程序运行时“java”字面量对象的引用就存在常量区，

6

public static void main(String[] args) {    String s = new StringBuilder("ja").append("va").toString();    System.out.println(s.intern() == "java");}

6这个例子是true ，Java语言说明中要求字符串字面量必须唯一，一样的字符串字面量必须为同一个String实例。所以“java“与intern返回的引用是同一个引用

7

public static void main(String[] args) {    String s = "abc";    String s1 = "abc";    String s2 = "abc";    System.out.println(s == s1);    System.out.println(s == s2);    System.out.println(s.intern() == s);    System.out.println(s1.intern() == s);    System.out.println(s2.intern() == s);}

打印的结果都是true，在常量区中存在的引用一直是”abc“，在堆中只创建了一个String对象（引用忽略）

8.

public static void main(String[] args) {    String s = "ab";    String s1 = "a" + "b";    System.out.println(s == s1);//true    String s2 = "c" + "d";    String s3 = new StringBuilder("c").append("d").toString();    System.out.println(s3 == s3.intern());//false    System.out.println(s2 == s3.intern());//true    String s4 = "efg" + "h";    String s5 = new StringBuilder("eg").append("f").toString();    System.out.println(s5.intern() == s5);//true}

java对”+“连接为优化后的值，javap查看

 String s4 = "efg" + "h";    String s5 = new StringBuilder("eg").append("f").toString();    System.out.println(s5.intern() == s5);//true

这段代码则证明了，”efg“在s5调用intern之前在常量池不存在它的引用，所以

s5.intern() == s5);为true

9.

public static void main(String[] args) {    String s = "a";    String s1 = s + "b";    String s2 = "ab";    System.out.println(s1 ==s2);    final String s3 = "c";    String s4 = s3 + "d";    String s5 = "cd";    System.out.println(s4 == s5);}

JVM只能优化常量值，对于引用，只有到真正运行到那一步的时候才能确定它的值，所以打印结果为false，true

然后再这样

 public static void main(String[] args) {        String s = "a";        String s1 = s + "b";    //        String s2 = "ab";//        System.out.println(s1 ==s2);        final String s3 = "c";        String s4 = s3 + "d";        String s5 = "cd";        System.out.println(s4 == s5);    }

查看.class文件

并不存在String ”ab“这两个值

今天累死