一、String的不可变性，实例化的两种方式以及预备知识

1.String的不可变性：
String是一个final类，不可被继承所以其字符序列不可变，
String对象的字符内容是存储在一个字符数组value[]中的，字符串是常量，创建之后不能更改

String的声明为下图：
在这里插入图片描述

2.String实例化的两种方式：
①通过字面量定义的方式
②通过new+构造函数的方式
3.预备知识：内存解析
堆：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。
栈：即虚拟机栈，用于存储局部变量等。局部变量存放了编译期可知长度的各种基本数据类型（boolean,byte,char,short,int,float,double,long等），对象引用（不等同于对象本身，是对象在堆内的首地址）方法执行完自动释放。
方法区：用于存放已被虚拟机加载的类信息，常量（常量池），静态变量，即时编译器编译后的代码等数据。

二、字面量定义实例化

public class 字面量实例化 {
    public static void main(String[] args) {

        String s1="abc";//字符串常量存储在字符串常量池里，目的是共享，并且字符串常量池中是不会存储相同内容的字符串的。
        //即s1,s2在栈中为一项，二者常量池指的是同一常量
        String s2="abc";
        String s3="111";
        System.out.println(s1==s2);//true，比较的是常量池中的地址
        s1="111";//value数组为final类型，所以不能对现有数组进行重新赋值，故新添加常量
        System.out.println(s1);//111，重写了指定内存区域赋值，指向字符串常量池中新添加的常量111
        System.out.println(s1==s2);//false，111和abc分别表示不同的内存区域，所以不相等。
        System.out.println(s1==s3);//true，指向相同的内存区域，所以相等
        System.out.println("*****************");
        String s4="abc";
        s4+="456";//经试验发现s4进行连接运算后，s2并未发生变化，所以s4依然是新创建的
        System.out.println(s4);//abc456，重写了指定内存区域赋值，重新指向内存区域赋值
        System.out.println(s2);//abc
        System.out.println("*****************");
        String s5="abc";//经试验发现调用了replace()方法后，s5值依旧保持不变，所以s6新创建的
        String s6=s5.replace("a","m");//重写了指定内存区域赋值，重新指向内存区域赋值
        System.out.println(s5);//abc
        System.out.println(s6);
        }
       }

在这里插入图片描述
以上代码图片解析如下：
String s1=“abc”;
String s2=“abc”;

String s1=“abc”;
String s2=“abc”;
s2=“111”;

String s4=“abc”;
s4+=“456”;

String s3=“abc”;
String s4=s3.replace(“a”,“m”);

小结论：

字符串常量存储在字符串常量池里，目的是共享，并且字符串常量池中是不会存储相同内容的字符串的。
①当对字符串重新赋值时，需要重新指定内存区区域赋值，不能使用原有的进行赋值
②当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的进行赋值
③当调用String的replace()方法修改指定字符或者字符串时也需要重新指定内存区域

String是不可变类型的，对它进行修改都需要重新造。

三、new+构造函数实例化

public class new实例化 {
    public static void main(String[] args) {
        String s3=new String("abc");字符串非常量对象存储在堆中，s3,s4保存的地址值，是数据在堆空间中开辟以后对应的地址值
        String s4=new String("abc");
        String s1="abc";
        String s2="abc";
        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 Student {
    String name;
    int age;
    public Student(){

    }
    public Student(String name,int age){
        this.age=age;
        this.name=name;
    }
    public static void main(String[] args) {
        Student s1=new Student("小贾",18);
        Student s2=new Student("小贾",18);
        System.out.println(s1.name.equals(s2.name));//true
        System.out.println(s1.name==s2.name);//true
    }//字符串非常量对象存储在堆中，s3,s4保存的地址值，是数据在堆空间中开辟以后对应的地址值，对象中的string属性存储在字符常量池中
}

代码运行结果如下：
在这里插入图片描述
以上代码图片解析如下：

四、String拼接操作对比

public class 测试类 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "1234";
        String s3 = "abc1234";
        String s4 = "abc" + "1234";
        String s5 = s1 + "1234";
        String s6 = "abc" + s2;
        String s7=s6.intern();
        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s5 == s6);//false
        System.out.println(s7== s3);//true
    }
}