1.常量与常量的拼接结果在常量池，原理是编译期优化

public void test1() {
String s1 = "a" + "b" + "c";//等同于"abc"
String s2 = "abc"; //"abc"-定是放在字符串常量池中，将此地址赋给s2
/*
*最终.java编译成.class,再执行. class
* string s1 = "abc";
* string s2 = "abc
*/
System.out.println(s1 == s2); //true
System.out.println(s1.equals(s2)); //true

}

2.常量池中不会存在相同内容的常量。

public void test2() {
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  
    System.out.println(s3 == s6);//false  
    System.out.println(s3 == s7);//false  
    System.out.println(s5 == s6);//false  
    System.out.println(s5 == s7);//false  
    System.out.println(s6 == s7);//false  
    //intern():判断宇符串常量池中是否存在javaEEhadoop值，如果存在，则返回常量池中javaEEhadoop的地址:  
    //如果字符串常量池中不存在javaEEhadoop，则在常量池中加载一份javaEEhadoop, 并返回此对象的地址。  
    String s8 = s6.intern();  
    System.out.println(s3 == s8);//true  
}

3.只要其中有一个是变量，结果就在堆中。变量拼接的原理是StringBuilder

public void test3() {
String s1 = "a";
String s2 = "b";
String s3 = "ab";
/*
如下的s1 + s2的执行细节: (变量s是我临时定义的)
1、StringBuilder s = new stringBuilder();
2、s. append("a")
3、s.append("b")
4、s.tostring() --> 约等于new string( "ab")
补充:在jdk5. 0之后使用的是StringBuilder,在jdk5.0之前使用的是stringBuffer
*/
String s4 = s1 + s2;//
System.out.println(s3 == s4);//false
}

/\*  
1.字符串拼接操作不一-定使用的是stringBuilder!  
如果拼接符号左右两边都是字符串常量或常量引用，则仍然使用编译期优化，即非stringBuilder的方式。  
2.针对于final 修饰类、方法、基本数据类型、引用数据类型的量的结构时，能使用上final的时候建议使用上。  
\*/  
public void test4() {  
    final String s1 = "a";  
    final String s2 = "b";  
    String s3 = "ab";  
    String s4 = s1 + s2;  
    System.out.println(s3 == s4);//true  
}

public void test5() {  
    String s1 = "javaEEhadoop";  
    String s2 = "javaEE";  
    String s3 = s2 + "hadoop";  
    System.out.println(s1 == s3);//false  
    final String s4 = "javaEE";//s4:常量  
    String s5 = s4 + "hadoop";  
    System.out.println(s1 == s5);//true  
}

4.如果拼接的结果调用intern()方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址。

拼接操作的效率对比：

通过StringBuilder 的append()的方式添加字符申的效率要远高于使用String的字符串拼接方式!
详情:1、StringBuilder的append()的方式:自始至终中只创建过-个StringBuilder的对象，使用String的字符串拼接方式:创建过多个StringBuilder和String的对象
　　 2、使用String的字符串拼接方式:内存中由于创建7铰多的StringBuilder和String的对象， 内存占用更大:如果进行GC，需要花费额外的时间

改进的空间:在实际开发中，如果基本确定要前前后后添加的字符串长度不高于某个限定值highLevel的情况下,建议使用构造器
StringBuilder s = new StringBuilder(highLevel);//new char[highLevel ]

intern()说明

String s = new String("1");
s. intern();//调用此方法之前，字符串常量池中已经存在了"1”
String s2 = "1";
System. out . println(s == s2);//jdk6: false jdk7/8: false
String s3 = new String("1") + new String("1");//s3变量记录的地址为: new String("11")
//执行完上一行代码以后，字符串常量池中,是否存在"11"呢?答案:不存在! !
s3. intern();//在字符串常量池中生成"11”。如何理解: jdk6: 创建了一个新的对象"11", 也就有新的地址。
//jdk7:此时常量中并没有创建"11",而是创建一个指向堆空间
String s4 = "11" ;//s4变量记录的地址:使用的是上一行代码执行时，在常量池中生成的"11”的地址
System. out . println(s3 == s4);//jdk6: false jdk7/8: true

new String("a") + new string("b")创建了几个对象?

对象1: new stringBuilder()
对象2: new string("a")
对象3: 常量池中的"a”
对象4: new String("b")
对象5: 常量池中的"b”

深入剖析: StringBuilder的tostring():
对象6 : new string( "ab")
强调一下，tostring()的调用，在字符串常量池中，没有生成"ab"