Java.lang.String类
1.String类定义
String 字符串对象本质上是一个 final 修饰的字符串数组对象, java字符串就是Unicode字符序列. 因为被final修饰, 所以字符串是常量，它们的值一旦被创建后不能改变。 Java没有内置的字符串类型, Java内部通过在标准Java类库中提供了一个预定义的String类,实现对字符串类型的支持
通过JDK源码前三行, 可以看出
1. String类被final修饰, 这说明String不可继承
2. String类的主力成员字段value是个final修饰的char[]数组。final修饰的字段创建以后就不可改变。注意, 虽然value是不可变，也只是value这个引用地址不可变。挡不住Array数组是可变的事实。
public static void main(String[] args) { final char[] value = {1, 2, 3}; int[] another = {4, 5, 6}; //编译器报错，value用final修饰，编译器不允许我把value指向堆区另一个地址 //value = another; value[0] = 100; //数组变成{100,2,3} }
Array的数据结构如图所示, 变量value存储的只是对象的引用(指向堆中的地址 0x1000)，数组对象的本体结构在heap堆。String类里的value用final修饰，只是说stack里的这个叫value的引用地址0x1000不可变。可没说heap里数组对象本身数据不可变。value[0] = 100时, 变量value引用的值0x1000并没有改变, 改变的是heap堆中对象本身的数据值.
2.字符串的创建
1.String a = "abc";
String b = "abc";
创建了一个对象,
第一行在字符串常量池创建"abc",
第二行检查字符串常量池中有"abc"对象,直接返回
2.String c = new String("abc"); String d = new String("abc"); System.out.println(c==d); // false
System.out.println(c.intern()==d.intern()); //true 总共创建了3个对象
第一行在堆和字符串常量池中各创建一个"abc"
第二行在堆中创建一个"abc", 常量池中已有, 不创建
3.String s = "a" + "b" + "c"; 只创建了1个对象 赋值符号右边的"a"、"b"、"c"都是常量,对于常量，编译时就直接存储它们的字面值而不是它们的引用,在编译时就直接将它们连接的结果提取出来变成了"abc",
该语句在class文件中就相当于String s = "abc" ,然后当JVM执行到这一句的时候， 就在String pool里找 ,如果没有这个字符串，就会产生一个
4.String s1 = "abc"; String s2 = "a"; String s3 = "bc"; String s4 = s2 + s3; System.out.println(s1 == s4); // false
因为s2+s3实际上是使用StringBuilder.append来完成，会生成不同的对象。
s1指向常量池"abc",
s4指向堆中"abc"(append连接而来)
5.String S1 = "abc";
final String S2 = "a";
final String S3 = "bc";
String S4 = S2 + S3;
System.out.println(S1 == S4); // true
因为final变量在编译后会直接替换成对应的值,所以实际上等于s4="a"+"bc"，而这种情况下，编译器会直接合并为s4="abc"，所以最终s1==s4。
3. String类常量池内存分析,基于JDK1.7 (分析: https://blog.csdn.net/qq_34115899/article/details/86583262#commentsedit)
问题一:
String h = new String("cc"); // 第一行创建2个对象, 堆中对象"cc", 常量池对象"cc" String intern = h.intern(); // intern 指向常量池中对象0x333 System.out.println(intern == h); // h指向堆中对象0x001, 地址引用不同,所以false
问题二:
String str2 = new String("str") + new String("01"); // 堆中有"str","01","str01" 三个对象; 常量池中有 "str","01" 两个对象 String str1 = "str01"; // 常量池中创建"str01"对象, 变量str1 指向常量池中对象 str2.intern(); // 检查常量池中已经有了"str1"对象, 返回对象引用时,没有变量接收, 相当于啥都没干 System.out.println(str2 == str1); // false
问题三:
String str2 = new String("str") + new String("01"); String str1 = "str01"; String str3 = str2.intern(); System.out.println(str3 == str1); // true
问题四:
String str2 = new String("str") + new String("01"); str2.intern(); String str1 = "str01"; System.out.println(str2 == str1); // true String str3 = new String("str01"); str3.intern(); String str4 = "str01"; System.out.println(str3 == str4); // false
问题五:
4.为什么String类被设计为不可变的,是否真的不可变?
1.如何保证String不可变
1. 对于属性不提供设值方法
2. 所有的属性定义为private final
3. 类声明为final不允许继承
4.Return deep cloned objects with copied content for all mutable fields in class(为类中的所有可变字段返回具有复制内容的深度克隆对象)
注意：不用final关键字也可以实现对象不可变，使用final只是显示的声明，提示开发者和编译器为不可变。
2. 为什么String类被设计为不可变(加final)
1.为了实现字符串池, 只有当字符串是不可变的，字符串常量池才有可能实现。
字符串常量池(String pool, String intern pool, String保留池) 是Java堆内存中一个特殊的存储区域, 当创建一个String对象时,假如此字符串值已经存在于常量池中,则不会创建一个新的对象,而是引用已经存在的对象。假若字符串对象允许改变,那么String interning将不能实现, 比如改变一个对象会影响到另一个独立对象. 严格来说，这种常量池的思想,是一种优化手段.
jdk1.6 以及之前,字符串常量池是存在于永久代中的（方法区）,频繁使用,会造成该区域内存占有过大，造成垃圾收集器的gc 从而影响程序的运行
jdk 1.7 常量池移动到了堆空间中,并且常量池中只存储字符串的引用,不再存储字符串值
jdk1.8 又进行改变，字符串常量池已经不存在,又出现了一个metaSpace(元空间)
2.为了线程安全
如果字符串是可变的，那么会引起很严重的安全问题。譬如，数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接，或者在socket编程中，主机名和端口都是以字符串的形式传入。因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子，改变字符串指向的对象的值，造成安全漏洞。
因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。
3.为了实现String可以创建HashCode不可变性
因为字符串是不可变的，所以在它创建的时候HashCode就被缓存了，不需要重新计算。这就使得字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。
参考:
String s = a+b+c+d+e;创建了几个对象的详细分析?
String，StringBuilder，StringBuffer 实现原理解析
