先让大家做个面试题：
String a = "hello";
String b = new String("hello");
System.out.println(a == b);//false
String c = "world";
System.out.println(c.intern() == c);//true
String d = new String("mike");
System.out.println(d.intern() == d);//false
String e = new String("jo") + new String("hn");
System.out.println(e.intern() == e);//true
String f = new String("ja") + new String("va");
System.out.println(f.intern() == f);//false
如果大家能一题不差的全做对，接下来的内容应该不用看了。如果不能并且有兴趣的话，可以稍微了解一下以下内容。
字符串常量池
在上一篇文章已经稍微了解过字符串常量池了，它是java为了节省空间而设计的一个内存区域，java中所有的类共享一个字符串常量池。比如A类中需要一个“hello”的字符串常量，B类也需要同样的字符串常量，他们都是从字符串常量池中获取的字符串，并且获得得到的字符串常量的地址是一样的。
实际上，为了提高匹配速度，即更快的查找某个字符串是否存在于常量池，Java在设计字符串常量池的时候，还搞了一张stringtable，stringtable有点类似于我们的hashtable，里面保存了字符串的引用。我们可以根据字符串的hashcode找到对应entry，如果没冲突，它可能只是一个entry，如果有冲突，它可能是一个entry链表，然后Java再遍历entry链表，匹配引用对应的字符串，如果找得到字符串，返回引用，如果找不到字符串，会把字符串放到常量池中，并把引用保存到stringtable里。
怎么样才能进入字符串常量池
往细讲，只有执行了ldc指令的字符串才会进入字符串常量池。什么意思呢？先看一个例子：
public static void main(String[] args) {
String a = "hello";
}
Constant pool:
#17 = String #18 // hello
#18 = Utf8 hello
{
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Error: unknown attribute
org.aspectj.weaver.MethodDeclarationLineNumber: length = 0x8
00 00 00 10 00 00 00 BA
Code:
stack=1, locals=1, args_size=1
0: ldc #17 // String hello
2: pop
3: return
LineNumberTable:
line 17: 0
line 18: 3
LocalVariableTable:
Start Length Slot Name Signature
0 4 0 args [Ljava/lang/String;
}
SourceFile: "ClassPoolTest.java"
在这里0: ldc #17,#17对应的“hello”，如果字符串常量池中已经存在“hello”，java不会做什么事，但是如果字符串常量池中没有该字符串常量，java会把该字符串常量放到常量池中，并且把引用放到stringtable中。
什么时候才会用到ldc指令
凡是有双引号括起字符串的地方就会用到ldc指令,比如上面的String a = "hello"。
我们再来看看几个例子：
public class ClassPoolTest {
String a = "hello";
public static void main(String[] args) {}
}
我们执行完main以后，hello不会进入字符串常量池。因为String a = "hello"是ClassPoolTest 的成员变量，成员变量只有在执行到构造方法的时候才会初始化。不信我们来看构造函数的反编译代码：
public pool.ClassPoolTest();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: aload_0
1: invokespecial #10 // Method java/lang/Object."<init>":()V
4: aload_0
5: ldc #12 // String hello
7: putfield #14 // Field a:Ljava/lang/String;
10: return
LineNumberTable:
line 13: 0
line 14: 4
line 13: 10
LocalVariableTable:
Start Length Slot Name Signature
0 11 0 this Lpool/ClassPoolTest;
public class ClassPoolTest {
static String a = "hello";
public static void main(String[] args) {}
}
执行完main以后，hello会进入常量池，因为static String a = "hello"是ClassPoolTest 静态变量，我们执行静态方法main之后张初始化静态变量，如下：
static {};
descriptor: ()V
flags: ACC_STATIC
Code:
stack=1, locals=0, args_size=0
0: ldc #10 // String hello
2: putstatic #12 // Field a:Ljava/lang/String;
5: return
LineNumberTable:
line 14: 0
LocalVariableTable:
Start Length Slot Name Signature
可见hello已经被添加到字符串常量池中。
intern有什么用
intern的作用是把new出来的字符串的引用添加到stringtable中，java会先计算string的hashcode，查找stringtable中是否已经有string对应的引用了，如果有返回引用（地址），然后没有把字符串的地址放到stringtable中，并返回字符串的引用（地址）。
我们继续看例子：
public static void main(String[] args) {
String a = new String("haha");
System.out.println(a.intern() == a);//false
}
因为有双引号括起来的字符串，所以会把ldc命令，即"haha"会被我们添加到字符串常量池，它的引用是string的char数组的地址，会被我们添加到stringtable中。所以a.intern的时候，返回的其实是string中的char数组的地址，和a的string实例化地址肯定是不一样的。
String e = new String("jo") + new String("hn");
System.out.println(e.intern() == e);//true
new String("jo") + new String("hn")实际上会转为stringbuffer的append 然后tosring()出来，实际上是new 一个新的string出来。在这个过程中，并没有双引号括起john，也就是说并不会执行ldc然后把john的引用添加到stringtable中，所以intern的时候实际就是把新的string地址（即e的地址）添加到stringtable中并且返回回来。
String f = new String("ja") + new String("va");
System.out.println(f.intern() == f);//false
或许很多朋友感觉很奇怪，这跟上面的例子2基本一模一样，但是却是false呢？这是因为java在启动的时候，会把一部分的字符串添加到字符串常量池中，而这个“java”就是其中之一。所以intern回来的引用是早就添加到字符串常量池中的”java“的引用，所以肯定跟f的原地址不一样。
