深入理解String、StringBuffer和StringBuilder
1、String类的特性
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
private final char value[];
String是被final修饰的类，不能被继承；
String实现了Serializable和Comparable接口，表示String支持序列化和可以比较大小；
String底层是通过char类型的数据实现的，并且被final修饰，所以字符串的值创建之后就不可以被修改，具有不可变性。
2、深入理解String的不可变性
通过字面量方式为字符串赋值时，此时的字符串存储在方法区的字符串常量池中，并且在字符串常量池中不会存储相同内容的字符串。
String s1="hi";
String s2="hi";
s1="hello";
刚开始字符串s1和s2内容相等，都指向字符串常量池中的同一个地址，如下图所示：
当s1值的改变之后，此时s2的值不变还是指向原来的内存地址，但是s1会重新分配内存地址进行赋值，如下图所示：
总结1：String字符串具有不可变性，当字符串重新赋值时，不会在原来的内存地址进行修改，而是重新分配新的内存地址进行赋值。
String s3="abc";
String s4=s3+"def";
System.out.println(s3); //abc
总结2：当字符串进行拼接时，也不会在原来的内存地址进行修改，而是重新分配新的内存地址进行赋值。
String s5="abcd";
String s6=s5.replace("d","g");
System.out.println(s5);
此时的内存结构如下图所示：
总结3：当调用String的replace方法修改指定的字符或字符串时，也不会在原来的内存地址进行修改，也是重新分配新的内存地址进行赋值。
3、String实例化的两种方式
方式一：通过字面量方式实例化
String str = "abc";
方式二：通过new+构造器的方式实例化
String str=new String("abc");
4、String两种实例化方式的对比
通过字面量方式为字符串赋值时，此时的字符串存储在方法区的字符串常量池中；
通过new+构造器方式实例化字符串时，字符串对象存储在堆中，但是字符串的值仍然存储在方法区的常量池中。如下图所示：
//通过字面量方式为字符串赋值时，此时的字符串存储在方法区的字符串常量池中
String s1="hello";
String s2="hello";
//通过new+构造器方式实例化字符串时，字符串对象存储在堆中
String s3=new String("hello");
String s4=new String("hello");
System.out.println(s1==s2);//true
System.out.println(s1==s3);//false
System.out.println(s1==s4);//false
System.out.println(s3==s4);//false
public class Person {
public String name;
public int age;
Person(){}
Person(String name,int age){
this.name=name;
this.age=age;
}
}
public static void main(String[] args) {
Person p1 = new Person("Tom",18);
Person p2 = new Person("Tom",18);
System.out.println(p1.name==p2.name); //true
}
此时的内存结构如下图所示：
如果p2中name值进行了修改，那么就会在字符串常量池中新生成一个修改后的值，然后改变堆中name指向的地址值，内存结构就会变成如下图所示：
面试题：使用String str=new String(“hello”)方式创建对象，一共创建了几个对象？
一共会创建两个对象，一个是使用new创建的对象，存储在堆中；另一个是常量对象"hello"，存储在字符串常量池中。
5、String不同拼接方式的对比
public static void main(String[] args) {
String s1="Hello";
String s2="World";
String s3="HelloWorld";
String s4="Hello"+"World";
String s5=s1+"World";
String s6="Hello"+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
String s8=s5.intern();
System.out.println(s3==s8); //true
}
(1)Java中有常量优化机制，“Hello"和"World"本身就是字符串常量，所以在编译时，会直接把"Hello"和"World"合并成"HelloWorld"字符串，又因为在执行s3的时候已经在常量池中创建了"HelloWorld”，所以s3==s4。
(2)当变量与字面量或变量与变量进行拼接时，会在堆中创建一个StringBuilde对象，然后使用StringBuilder的append()方法将变量与字面量或变量与变量进行拼接，最后调用toString()方法转成String对象。所以s5、s6、s7指向的都是堆内存中String对象的地址值。
(3)使用intern()这个方法时，首先会检查字符串常量池中是否有对应的字符串，如果存在则返回这个字符串的引用；否则会先将字符串添加到字符串常量池中，然后再返回这个字符串的引用。所以s3==s8。
易错的笔试题
public static void main(String[] args) {
final String s1="Hello";
String s2="HelloWorld";
String s3=s1+"World";
System.out.println(s2==s3); //true
}
此时的s1用final进行修饰，表示的是一个常量，所以此时s1+“World"就相当于"Hello”+“World”，结果仍然是一个常量，所以s2==s3。
6、深入理解StringBuffer和StringBuilder
StringBuffer、StringBuilder和String类似，底层也是用一个数组来存储字符串的值，并且数组的默认长度为16，即一个空的StringBuffer对象数组长度为16。实例化一个StringBuffer对象即创建了一个大小为16个字符的字符串缓冲区。但是当我们调用有参构造函数创建一个StringBuffer对象时，数组长度就不再是16了，而是根据当前对象的值来决定数组的长度，数组的长度为“当前对象的值的长+16”。所以一个 StringBuffer 创建完成之后，有16个字符的空间可以对其值进行修改。如果修改的值范围超出了16个字符，会先检查StringBuffer对象的原char数组的容量能不能装下新的字符串，如果装不下则会对 char 数组进行扩容。
那StringBuffer是怎样进行扩容的呢？
扩容的逻辑就是创建一个新的 char 数组，将现有容量扩大一倍再加上2，如果还是不够大则直接等于需要的容量大小。扩容完成之后，将原数组的内容复制到新数组，最后将指针指向新的 char 数组。StringBuffer和StringBuilder中常用
面试题：String、StringBuffer和StringBuilder的异同？
相同点：底层都是通过char数组实现的
不同点：
String对象一旦创建，其值是不能修改的，如果要修改，会重新开辟内存空间来存储修改之后的对象；而StringBuffer和StringBuilder对象的值是可以被修改的；
StringBuffer几乎所有的方法都使用synchronized实现了同步，线程比较安全，在多线程系统中可以保证数据同步，但是效率比较低；而StringBuilder 没有实现同步，线程不安全，在多线程系统中不能使用 StringBuilder，但是效率比较高。
如果我们在实际开发过程中需要对字符串进行频繁的修改，不要使用String，否则会造成内存空间的浪费；当需要考虑线程安全的场景下使用 StringBuffer，如果不需要考虑线程安全，追求效率的场景下可以使用 StringBuilder。