String 的基本特性
两种实例化方式
String s1 = "hello";//字面量的定义方式
String s2 = new String("hello");
String 声明为final， 是不可被继承的
String实现了Serializable接口，表示支持序列化； 实现了Comparable接口，表示支持比较大小
JDK1.8及之前String底层是char[] 数组， 而JDK1.9之后变成byte[] 数组加上编码标记，节约了一些空间
String的不可变性，不管是拼接还是API的替换，都是新造一个字符串，不会改变原来的字符串。
字符串常量池【String Pool】
字符串常量池中是不会存储相同的字符串的
String Pool是一个固定大小的Hashtable【数组加链表】，JDK6中默认大小长度是1009，JDK7中默认长度是60013，1009是可设置的最小值【如果String pool的长度小，而Sting 有很多的话，就会导致Hash冲突，从而使得链表会很长，影响调用】
使用-XX:StringTableSize=xx 设置
String的内存分配
JDK6-永久代
JDK7-永久代，字符串常量池拿到了堆空间
JDK8-元空间，字符串常量池还在堆空间
字符串拼接操作
1.常量与常量的拼接结果在常量池，原理是编译器优化
2.只要有变量，结果就在堆中（相当于new对象），变量拼接原理是：StringBuilder
3.如果拼接的结果调用intern()方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址。
示例代码：
@Test
public void test1(){
String s1 = "a"; //”“引号赋值，直接在字符串常量池创建这个字符串,然后返回这个字符字面量
//然后将变量保存到局部变量表的索引1位置，索引0位置放的是this
String s2 = "b"; //同理
String s3 = "ab"; //同理
/*
s1+s2 执行细节：【如果s1,s2 为字面量或者加了final 则会-使用编译期优化，会自动合并到一起】
①StringBuilder s = new StringBuilder();
②s.append("a");
③s.append("b");
④s.toString(); --> 约等于 new String("ab");
*/
String s4 = s1 + s2;//s1 s2 是变量， 如果s1,s2是常量的话就不会new了
System.out.println("s3==s4 " + s3 == s4); //false
}
示例代码的字节码：
0 ldc #2 <a>
2 astore_1
3 ldc #3 <b>
5 astore_2
6 ldc #4 <ab>
8 astore_3
# s4创建开始
9 new #5 <java/lang/StringBuilder>
12 dup
13 invokespecial #6 <java/lang/StringBuilder.<init> : ()V>
16 aload_1
17 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
20 aload_2
21 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
24 invokevirtual #8 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
27 astore 4
29 getstatic #9 <java/lang/System.out : Ljava/io/PrintStream;>
32 new #5 <java/lang/StringBuilder>
35 dup
36 invokespecial #6 <java/lang/StringBuilder.<init> : ()V>
# s4创建完成
39 ldc #10 <s3==s4 >
41 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
44 aload_3
45 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
48 invokevirtual #8 <java/lang/StringBuilder.toString : ()Ljava/lang/String;>
51 aload 4
53 if_acmpne 60 (+7)
56 iconst_1
57 goto 61 (+4)
60 iconst_0
61 invokevirtual #11 <java/io/PrintStream.println : (Z)V>
64 return
intern() 的使用
String info = new String("AAA").intern();
intern方法会从字符串常量池中查询当前字符串是否存在
若不存在，就会将当前字符串放入常量池中，返回常量池中字符串的地址，
jdk7/8后，如果堆空间已经有"AAA"字符串，则会把字符串"AAA"的地址放入常量池
若存在，返回常量池中的字符的地址
【字符串常量池中可能有字符串字面量和字符串地址，但是不会有equal 为true的两个对象】
面试题目
创建了几个对象
1.new String(“AB”) 会创建几个对象。
答：一个或者两个
代码及字节码：
@Test
public void stringNewTest(){
String str = new String("AB");
}
/**************字节码**********************/
0 new #12 <java/lang/String> #/*堆空间new了一个*/
3 dup
4 ldc #13 <AB> #/*常量池创建了一个*/
6 invokespecial #14 <java/lang/String.<init> : (Ljava/lang/String;)V>
9 astore_1
10 return
解释：由字节码可以很容易看出，代码创建了两个对象， 一个是堆空间new的对象，一个是字符串常量池中创建了一个对象
创建一个对象的情况是：当字符串常量池中已经有了字符串"AB",就不会再在字符串常量池创建了
2.new String(“a”) + new String(“b”)会创建几个对象？
代码及字节码：
@Test
public void stringNewTest(){
//String str = new String("AB");
String str = new String("A") + new String("B");
}
/*********************字节码******************************/
0 new #5 <java/lang/StringBuilder> #//一
3 dup
4 invokespecial #6 <java/lang/StringBuilder.<init> : ()V>
7 new #12 <java/lang/String> #//二
10 dup
11 ldc #13 <A> #//三
13 invokespecial #14 <java/lang/String.<init> : (Ljava/lang/String;)V>
16 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
19 new #12 <java/lang/String> #//四
22 dup
23 ldc #15 <B> #//五
25 invokespecial #14 <java/lang/String.<init> : (Ljava/lang/String;)V>
28 invokevirtual #7 <java/lang/StringBuilder.append : (Ljava/lang/String;)Ljava/lang/StringBuilder;>
31 invokevirtual #8 <java/lang/StringBuilder.toString : ()Ljava/lang/String;> #//六 toString()方法
34 astore_1
35 return
解释：
- 两个变量拼接，会首先创建出一个StringBuilder()对象
- new String(“A”)
- 在字符串常量池中创建"A"
- new String(“B”)
- 在字符串常量池中创建"B"
- StringBuilder的toString()方法，会new String(“AB”)，但不会在字符串常量池创建"AB"
StringBuilder的toString()方法源码刨析：
@Override
public String toString() {
// Create a copy, don't share the array
return new String(value, 0, count);
}
/********************字节码***************************/
0 new #80 <java/lang/String>
3 dup
4 aload_0
5 getfield #234 <java/lang/StringBuilder.value : [C>
8 iconst_0
9 aload_0
10 getfield #233 <java/lang/StringBuilder.count : I>
13 invokespecial #291 <java/lang/String.<init> : ([CII)V>
16 areturn
从字节码也可以看出StringBuilder()的toString()方法会创建一个new String(“AB”),但是不会在字符串常量池创建"AB"
所以new String(“a”) + new String(“b”) 这句话执行后，字符串常量池中不会有"AB"
如何保证变量s指向的是字符串常量池中的数据呢？
方式一：String s = “ygstriver”;
方式二：调用intern(), String s = new String(“ygstriver”).intern()
intern() 面试难题
@Test
public void stringIntern(){
String s1 = new String("A");
s1.intern(); //未执行这句代码之前，字符串常量池中就有"A"了
//执行了这句话，因为常量池中有"A"了，所以不会做任何事，返回值为字符串常量池中"A"的地址
String s2 = "A";
System.out.println(s1 == s2);// jdk6: false, jdk7/8: false
String s3 = new String("A") + new String("B");//约等于 new String("AB"),唯一区别是没有在常量池创建"AB"或"AB"的引用
s3.intern(); //这句话会在常量池创建"AB"
// JDK6，字符串常量池在永久代中，所有此时是在常量池中新创建了一个"A"的字面量。而
//JDK7/8, 字符串在堆空间中， new的对象也在堆空间中，所以字符串常量池不会创建一个新的"A"的字面量，
//而是会创建一个字符串对象的引用，这个引用指向堆空间中new出来的字符串
String s4 = "AB";//从字符串常量池取值，取到AB的引用，这引用正式new String("AB")的地址值
System.out.println(s3 == s4); //jdk6: false, jdk7/8: true
}
解释：
- s1是在堆空间创建出的字符串对象，s2是字符串常量池中的对象，他们不相等很容易理解。
- s3赋值代码执行完，字符串常量池中是没有"AB"字符串的.
而执行了s3.intern()之后，字符串常量池有"AB"了，
但是 jdk7/8中这个"AB"不是字面量"AB"，而是一个引用，引用指向堆空间中new String(“AB”)的地址，
s4引号赋值，从字符串常量池取到"AB"的引用，而这个引用对应的地址值正是new String(“AB”)的地址值，也就是s3的值，所以s3 == s4
图解：
小拓展：
String s3 = new String("A") + new String("B"); //执行完这句代码字符串常量池不存在"AB"
String s4 = "AB"; //执行完这句 字符串常量池存在 "AB"的字面量,返回的是字符串常量池中"AB"的地址
String s5 = s3.intern(); //执行完这句，字符串常量池还是存在"AB"的字面量，这句话返回的也是字符串常量池中"AB"的地址
System.out.println(s3 == s4); //false
System.out.println(s5 == s4); //true
练习题1：
String ss1 = new String("a") + new String("b");
String ss2 = ss1.intern();
System.out.println(ss2 == "ab"); //true
System.out.println(ss1 == "ab"); //jdk6:false jdk7/8: true
练习题2：
String ss3 = new String("ab");
String ss4 = ss3.intern();
System.out.println(ss3 == ss4); //false