Java中 String类的详解

一、String类的使用：

• String：字符串，使用一对“”引起来表示
• String声明为final的，不可以被继承
• 字符串的字符使用Unicode进行编码，一个字符(不区分字母还是汉字)占两个字节
• String实现了Serializable接口：表示字符串是支持序列化的，说明可以在网络上传输。
• 实现了Comparable接口：表示String可以比较大小
• String类内部定义了final char[] value用于存储字符串数据
• 一定要注意：value是一个final类型，不可以修改：即value不能指向新的地址，但是单个字符内容是可以变化的。
• String代表不可变的字符序列，简称：不可变性

体现：

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

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

3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

• 通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中
• 字符串常量池中是不会存储相同内容的字符串的

案例代码如下：

package www.demo1;

import org.junit.Test;

public class StringTest {
    @Test
    public void test1(){
        final char[] value = {'a', 'b', 'c'};
        char[] v2 = {'t', '0', 'm'};
        value[0] = 'H';
//        value=v2; //不可以修改value地址

        //"abc" 字符串常量，双引号括起的字符序列 
        String s1="abc"; //字面量的定义方式
        String s2="abc";
        s1="hello";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("***********************");
        //比较s1,s2的地址值,结果为true
        System.out.println(s1==s2);

        String s3="abc";
        s3+="def";
        System.out.println(s3);
        
        System.out.println("***********************");
        String s4="abc";
        String s5=s4.replace("a","m");
        System.out.println(s4);
        System.out.println(s5);
    }
}

 

二、String实例化的方式：
方式一：通过字面量定义的方式
方式二：通过new + 构造器() 的方式
代码理解：

        //通过字面量定义的方式:此时数据abc声明在方法区中的字符串常量池中
        String s1="abc";
        String s2="abc";
        //通过new+构造器的方式: 此时s3,s4保存的地址值，是数据在堆空间中开辟以后对应的地址值
        String s3 = new String("abc");
        String s4 = new String("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
        System.out.println("**************************");
        Person p1 = new Person("Tom",14);
        Person p2 = new Person("Tom",14);
        System.out.println(p1.name.equals(p2.name));//true,因为比较的是实体内容(String重写了equals()方法)
        System.out.println(p1==p2);//false new的两个对象地址值是不一样的
        System.out.println(p1.name==p2.name); //true
        p1.name="Lay";
        System.out.println(p2.name); //结果为Tom

 

结论：

常量与常量的拼接结果在常量池，且常量池中不会存在相同内容的常量
只要其中有一个结果是变量，结果就在堆中
如果拼接的结果调用intern()方法，返回值就在常量池中
加上代码便于理解：

        String s1 = "Java";
        String s2 = "Android";
        String ss ="JavaAndroid";

        String s3 = "Java"+"Android";
        String s4 = s1 + "Android";
        String s5 = "Java" + s2;
        String s6 = s1 + s2;

        System.out.println(ss==s3);//true
        System.out.println(ss==s4); //false
        System.out.println(ss==s5);//false
        System.out.println(ss==s6);//false
        System.out.println(s4==s5);//false

        String s7=s4.intern();
        System.out.println(ss==s7);//true

 

额外补充**************************

创建String对象的两种方式：

 

 

String的内存布局

 

 

String的相关测试

测试题1：

public class StringExercise01 {
public static void main(String[] args) {
String a = "abc";
String b = "abc";
//String重写了equals方法 ,比较的是具体的值，所以为true
System.out.println(a.equals(b)); //true

//a 首先看常量池有没有abc
//b 首先看常量池有没有abc 有，就将b直接指向abc
//所以地址值是一样的
System.out.println(a == b); //true
}
}

 

测试题2：

public class StringExercise02 {
public static void main(String[] args) {
String a = "ly";
String b = new String("ly");
System.out.println(a.equals(b)); //true
System.out.println(a == b); //false
System.out.println(a == b.intern()); //true
System.out.println(b == b.intern()); //false

//当调用intern()方法时，如果池已经包含一个等于此String对象的字符串(用equals(Object)方法确定)
//则返回池中的字符串.否则，将此String对象添加到池中，并返回此String对象的引用
//解读：b.intern() 方法最终返回的是常量池的地址(对象)
}
}

 

测试题3：

public class StringExercise03 {
public static void main(String[] args) {
String s1 = "ly"; //s1 指向常量池的ly
String s2 = "java"; //s2 指向常量池的java
String s4 = "java"; //s4 指向常量池的java
String s3 = new String("java"); //指向堆中的对象

System.out.println(s2 == s3); //false
System.out.println(s2 == s4); //true
System.out.println(s2.equals(s3)); //true
System.out.println(s1 == s2); //false
}
}

 

测试题4：

public class StringExercise04 {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "lyedu";
Person p2 = new Person();
p2.name = "lyedu";

System.out.println(p1.name.equals(p2.name)); //比较的内容 true
System.out.println(p1.name == p2.name); //true
//"lyedu"返回的地址：就是在常量池中的地址
//p1.name 指向的也是常量池中的"lyedu" 对应的地址
System.out.println(p1.name == "lyedu"); //true

String s1 = new String("bcde");
String s2 = new String("bcde");
System.out.println(s1 == s2); //false
}
}

class Person {
public String name;
}

 

对应的内存布局图如下：

 

 

测试题5：

//以下语句创建了几个对象，并画出内存布局图
String s1="hello";
s1="haha";
//创建了两个对象

内存布局图

String类相关的面试题

面试题1：

//创建了几个对象？ 只有1个对象
String a = "hello" + "abc";//等价于==>String a = "helloabc";
System.out.println(a);

面试题2：

一共有3个对象，内存布局图如下：

具体代码和讲解如下：

public class StringExercise05 {
public static void main(String[] args) {
String a = "hello"; //创建a对象
String b = "abc"; //创建b对象
//解读
//1.先创建一个StringBuilder sb = new StringBuilder();
//2.执行 sb.append("hello");
//3.执行sb.append("abc");
//4.String c = sb.toString();
//最后其实是 c 指向堆中对象的(String) value[]->池中 "helloabc"
String c = a + b; 
String d = "helloabc";
System.out.println(c == d); //false

String e = "hello" + "abc";
System.out.println(d == e);//true
}
}

 

该题小结：
底层是StringBuilder sb = new StringBuilder();
sb.append(a); sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的。

重要规则：

String c1=“ab” + “cd”; 常量相加，看的是池。
String c1 = a + b; 变量相加，是在堆中。
面试题3：

public class StringExercise06 {
public static void main(String[] args) {
String s1 = "lyedu";//指向常量池中的"lyedu"
String s2 = "java";//指向常量池中的"java"
String s5 = "lyedujava"; //指向常量池中的"lyedujava"
String s6 = (s1 + s2).intern(); //指向池中的 "lyedujava"
System.out.println(s5 == s6); //true
System.out.println(s5.equals(s6)); //true
}
}

 

面试题4:

public class StringExercise07 {
public static void main(String[] args) {
Test1 ex = new Test1();
ex.change(ex.str, ex.ch);
System.out.println(ex.str + " and ");
System.out.println(ex.ch);
}
}

class Test1 {
String str = new String("ly");
final char[] ch = {'j', 'a', 'v', 'a'};

public void change(String str, char ch[]) {
str = "java";
ch[0] = 'h';
}
}

 

输出结果为：

ly and
hava

以上是String字符串的讲解，有任何问题都可以在评论区指出！