摘要：

• String概述
• “+”，StringBuffer，StringBuilder
• intern方法
• String内存分布和创建时对象生成情况等常见问题详解

String概述

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;

以上是jdk1.8中对String类的定义，由此我们可以得出以下几个结论：

1. String类被final关键字修饰，意味着String类不能被继承，并且它的成员方法都默认为final方法；字符串一旦创建就不能再修改。
2. String类实现了Serializable、CharSequence、 Comparable接口。
3. String实例的值是通过字符数组实现字符串存储的。

“+”，StringBuffer，StringBuilder

• java中 当"+" 前后出现字符串时表示字符串拼接的操作，因为String是final修饰的，创建后就不可变，所以“+”底层实际是创建了一个StringBuilder对象，然后调用append方法去拼接字符串，再调用toString方法生成一个新的String。
• 只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。
• 对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中。
• StringBuffer和StringBuilder都是可变的字符序列
• StringBuffer的append方法使用了synchronized，所以是线程安全的，StringBuilder是线程不安全的。所以相应的，StringBuilder的效率比StringBuffer快。

intern方法

/**
     * Returns a canonical representation for the string object.
     * <p>
     * A pool of strings, initially empty, is maintained privately by the
     * class {@code String}.
     * <p>
     * When the intern method is invoked, if the pool already contains a
     * string equal to this {@code String} object as determined by
     * the {@link #equals(Object)} method, then the string from the pool is
     * returned. Otherwise, this {@code String} object is added to the
     * pool and a reference to this {@code String} object is returned.
     * <p>
     * It follows that for any two strings {@code s} and {@code t},
     * {@code s.intern() == t.intern()} is {@code true}
     * if and only if {@code s.equals(t)} is {@code true}.
     * <p>
     * All literal strings and string-valued constant expressions are
     * interned. String literals are defined in section 3.10.5 of the
     * <cite>The Java? Language Specification</cite>.
     *
     * @return  a string that has the same contents as this string, but is
     *          guaranteed to be from a pool of unique strings.
     */
    public native String intern();

intern方法是一个本地方法。作用就是调用该方法时先去字符串常量池中查找是否有相等的（equals）值，有就直接返回常量池中的引用。没有就将该字符串存入字符串常量池，再返回字符串常量池中的引用。

注意：jkd1.6之前常量池和堆是分开的，所以这里是在常量池里存的的具体的值。jdk1.6之后常量池和堆在一起，这里常量池中保存的是堆中对象的引用。

String内存分布几生成几个对象等常见问题详解

由于字符串对象的大量使用(它是一个对象，一般而言对象总是在heap分配内存)，Java中为了节省内存空间和运行时间(如比较字符串时，==比equals()快)，在编译阶段就把所有的字符串文字放到一个文字池(pool of literal strings)中，而运行时文字池成为常量池的一部分。文字池的好处，就是该 池中所有相同的字符串常量被合并，只占用一个空间。

主要就是两种情况：通过常量池创建和通过new创建

1. 通过常量池创建，JVM会首先检查在字符串常量池，如果在字符串常量池中存在了该字符串 ，此时就会将该字符串对象的地址值赋值给引用。如果字符串不在常量池中，就会在常量池中创建字符串,然后将字符串对象的地址值交给引用。所以最多只会创建一个对象。
2. 通过new创建，JVM会首先检查字符串常量池,如果字符串已经存在常量池中，直接复制堆中这个对象的副本，然后将堆中的地址值赋给引用，不会在字符串常量池中创建对象。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中，然后在堆中复制该对象的副本，并将对象的地址值交给引用。所以可能生成一个或者两个对象。

String s1 = "a";
String s3 = new String("a");
String s4 = new String("b");
String s2 = "b";
String s5 = "a" + "b";
String s6 = "a" + s4;
String s7 = s1 + s2;
String s8 = "ab";
final String s9 = "e";
final String s10 = "f";
String s11 = s9 + s10;
String s12 = "ef";
System.out.println(s1 == s3);        // false
System.out.println(s1.equals(s3));	 // true
System.out.println(s5 == s6);		// false
System.out.println(s5 == s7);		// false
System.out.println(s5.equals(s7));	// true
System.out.println(s5 == s8);		// true
System.out.println(s11 == s12);		// true

• s1 在常量池中生成了一个对象
• s3 常量池中已经有了，所以只在堆中创建了一个对象
• s4 常量池和堆中各创建了一个对象，共两个对象（这两个对象的字符串数组是同一个）
• s2 常量池中已经有了，没有重新创建对象
• s5 编译时将常量拼接好了，然后在常量池中创建了一个对象
• s6 生成一个StringBuilder对象用来拼接，最后toSting在堆中生成一个新的对象，共两个对象
• s7 与s6一样
• s8 常量池中已经有了，没有重新创建对象
• s9，s10都是在常量池中生成一个对象
• s11 使用final修饰的变量，在编译时替换成常量了，然后将常量拼接好在常量池中创建了一个对象

String s1 = new String("g");
s1.intern();
String s2 = "g";
System.out.println(s1 == s2);			// false
System.out.println(s1.intern() == s2);	 // true

String s3 = new String("h") + new String("i");
s3.intern();
String s4 = "hi";
System.out.println(s3 == s4);			// true
System.out.println(s3.intern() == s4);	 // true

String s5 = new String("j") + new String("k");
String s6 = "jk";
s5.intern();
System.out.println(s5 == s6);			// false
System.out.println(s5.intern() == s6);	 // true

• s1 在常量池中和堆中各创建了一个对象
• s1.intern调用时发现常量池中已经存在“g”了，所以返回常量池中“g”的引用
• s2 创建时发现常量池中已经存在了，不会生成新的对象，直接指向常量池的对象
• s1和s2指向不同的对象，所以不相等。s1.intern指向常量池的对象，和s2相等
• s3 在堆中生成两个匿名对象，一个StringBuilder对象，一个toString生成的对象，常量池中两个对象，共六个对象。最终生成的对象不会存放到字符串常量池中（参考上面“+”的定义）。
• s3.intern调用时发现常量池中没有“hi”，将堆中“hi”对象的地址存放在常量池中，所以s3.intern最终还是指向堆中的对象。
• s4 创建时发现常量池中已经存在了，直接返回常量池中的引用，所以s4最终也指向了堆中的“hi”对象。所以s3==s4，s3.intern() == s4
• s5 创建和s3过程一样
• s6 创建时发现常量池中没有，会在常量池中创建一个“jk”对象
• s5.intern调用时，发现常量池中已经存在“jk”，直接返回常量池中的对象地址。
• 所以s5和s6是指向不同的对象