字符串相关的类：String_string s4 = s1 + "world"; string s5 = s1 + s2;

String的特性：

1）String类：代表字符串。Java程序中的所欲字符串字面值（如“abc”）都作为此类的实现实例。

2）String使用一个final类，代表不可变的字符序列。

3）String对象的字符内容是存储在一个字符数组value[]中的。

public final class String
    implements java.io.Serializable,Comparable<String>,CharSequence{
    /** The value is used for character storage. */
    private final char value[];
 
    /** Cache the hash code for the string. */
    private int hash; //Default to 0

String:字符串，使用一对“”引起来表示

1.String声明为final的，不可被继承

2.String实现了Serializable接口：表示字符串是支持序列化的。

             实现了Comparable接口：表示String可以比较大小

3.String内部定义了final char[] value用于存储字符串数据

4.String：代表不可变的字符序列。简称：不可变性

        体现：

        a）当对字符串重新负值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。

       b）当前现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value。

        c）当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值。

5.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。

6.字符串池中是不会存储相同内容的字符串的。

String的实例化方式:

方式一：通过字面定义的方式：声明在方法区中的字符串常量池中。

方式二：通过new + 构造器的方式：是数据在堆空间中开辟空间以后对应的地址值。

String对象的创建：

（1)        String str="hello";

（2）//本质上this.value=new char[0];

        String s1=new String();

（3）//this.value=original.value;

        String s2=new String(String original);

（4）//this.value=Arrays.copyOf(value,value.length);

        String s3=new String(char[] a);

        String s4=new String(chaar[] a,int startIndex,int count);

String str1="abc";与String str2=new String("abc");的区别？

1）字符串常量存储在字符串常量池，目的是共享。

2）字符串非常量对象存储在堆中。

String s=new String(“abc”);方式创建对象，在内存中创建了介个对象？

创建了两个：一个是堆空间中new结构，另一个是char[]对应常量池中的数据：“abc”。

字符串的拼接：

1）常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量

2）只要有一个是变量，结果就在堆中

3）如果拼接结果调用intren()方法，返回值就在常量池中

eg：
String s1="hello"; //常量池

String s2="world";//常量池

String s3="hello"+"world";//常量池

String s4=s1+"world";//堆

String s5=s1+s2;//堆

String s6=(s1+s2).intern();//常量池

s3==s4//false   s3==s5//false  s4==s5//false   s3==s6//true

//尝试运行下面代码
public class StringTest {
 
    String str=new String("good");
    char[] ch={'t','e','s','t'};
 
    public void change(String str,char ch[]){
        str="test ok";
        ch[0]='b';
    }
 
    public static void main(String[] args) {
        StringTest ex=new StringTest();
        ex.change(ex.str,ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}

public class Person {
    String name;
    int age;
 
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public Person(){
    }
}
 
 
 
 
import java1.Person;
import jdk.jfr.StackTrace;
 
/*
String的使用
 */
public class StringTest {
 
    /*
    常量与常量拼接结果在常量池，只要有一个是变量，结果就在堆中
     */
    public void test3(){
        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(s5==s6);//false
        System.out.println(s3==s7);//false
        System.out.println(s5==s7);//false
        System.out.println(s6==s7);//false
 
        String s8=s5.intern();//返回值得到的s8使用的是常量池中已经存在的“javaEEhadoop”
        System.out.println(s3==s8);//true
    }
    /*
    String的实例化方式
    方式一：通过字面定义的方式
    方式二：通过new + 构造器的方式
     */
    public void test2(){
        //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
        String s1="javaEE";
        String s2="javaEE";
 
        //通过new + 构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
        String s3=new String("javaEE");
        String s4=new String("javaEE");
 
        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false
        System.out.println(s1==s4);//false
        System.out.println(s3==s4);//false
 
        System.out.println("*************");
        Person p1=new Person("Tom",12);
        Person p2=new Person("Ton",12);
 
        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name==p2.name);//true
 
        p1.name="Jerry";
        System.out.println(p2.name);//Tom
    }
 
    public void test1(){
        String s1="abc"; //字面量
        String s2="abc";
        s1="hello";
 
        System.out.println(s1==s2);
 
        System.out.println(s1); //hello
        System.out.println(s2); //abc
 
        System.out.println("*****************");
 
        String s3="abc";
        s3+="def";
        System.out.println(s3);//abcdef
        System.out.println(s2);
 
        System.out.println("***************");
 
        String s4="abc";
        String s5=s4.replace('a','m');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
    }
}