Java常用类与基础API--String的理解与不可变性

一、字符串相关类之不可变字符序列：String

（1）对String类的理解(以JDK8为例说明)

1、环境

【环境】

这里用JDK8演示。

将jdk版本换成8：

相应代码的语法规则基于8：（9之后的语法就不能使用了）

2、类的声明

Ctrl+N，输入String：

可以看到String的声明：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence

☕注意

• final：String是不可被继承的。
• Serializable：可序列化的接口。凡是实现此接口的类的对象就可以通过网络或本地流进行数据的传输（序列化）。
• Comparable：凡是实现此接口的类，其对象都可以比较大小。在这个接口里面有抽象方法，String类实现了这个接口里面的抽象方法，指明了怎么算叫“大”，怎么算叫“小”，给了一种标准（重写了方法）。
• CharSequence：字符序列。
• 可以看到String类实现了相关的接口，没有明显地写父类，也就是说它是继承Object类的。
• ：泛型。

3、内部声明的属性

①JDK8中：

private final char value[]; //存储字符串数据的容器

final : 指明此value数组一旦初始化，其地址就不可变。（常量）

比如将字符串定义成“hello”，本质上它就是存储在当前数组value[]里面的，此时value的长度是5，因为有5个字符。

②JDK9开始：为了节省内存空间，做了优化

private final byte[] value; //存储字符串数据的容器。

为什么变成了byte？

实际上String的对象在内存中存放，大部分String的对象只包含拉丁字母，拉丁字母只需要一个byte就可以存储了。

当初在讲基本数据类型的时候讲到char，在内存层面，一个char占2个字节，也就是说比如“a”是一个字符，在内存层面用2个字节来存放。

其实在ASCLL码中，a是97，在实际存储层面（硬盘），a用1个字节（byte）就可以存下。

如果是基于拉丁的，那就是一个字节（byte）存一个字符；如果是基于汉字的，两个字节拼在一起构成一个字符（char）。

JDK9相当于优化了内存空间。

（2）String的特性

• java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如"hello" ）都可以看作是实现此类的实例。
• 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。
• 字符串String类型本身是final声明的，意味着我们不能继承String。
• String对象的字符内容是存储在一个字符数组value[]中的。"abc" 等效于 char[] data={'h','e','l','l','o'}。

//jdk8中的String源码：
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[]; //String对象的字符内容是存储在此数组中
 
    /** Cache the hash code for the string */
    private int hash; // Default to 0

• private意味着外面无法直接获取字符数组，而且String没有提供value的get和set方法。
• final意味着字符数组的引用不可改变，而且String也没有提供方法来修改value数组某个元素值。
• 因此字符串的字符数组内容也不可变的，即String代表着不可变的字符序列。即，一旦对字符串进行修改，就会产生新对象。
• JDK9只有，底层使用byte[]数组。

public final class String implements java.io.Serializable, Comparable<String>, CharSequence { 
    @Stable
    private final byte[] value;
}

//官方说明：... that most String objects contain only Latin-1 characters. Such characters require only one byte of storage, hence half of the space in the internal char arrays of such String objects is going unused.

//细节：... The new String class will store characters encoded either as ISO-8859-1/Latin-1 (one byte per character), or as UTF-16 (two bytes per character), based upon the contents of the string. The encoding flag will indicate which encoding is used.

• Java 语言提供对字符串串联符号（“+”）以及将其他对象转换为字符串的特殊支持（toString()方法）。

（3）字符串常量的存储位置

1、举例

【举例】

@Test
public void test1(){
    String s1="hello";  //字面量的定义方式
}

String比较特别，可以通过字面量的方式来定义。

按道理，它是一个引用数据类型，是一个类，应该要new。

上面这种字面量的定义方式，“hello”放在了字符串常量池当中。

因为在开发中非常常用，所以专门给字符串开辟了一块空间，叫做“字符串常量池”。

字符串常量都存放在字符串常量池当中的。

---

若是再声明一个s2，也叫做“hello”。（将实体对象的地址给了s1）

public class StringDemo {
    @Test
    public void test1(){
        String s1="hello";  //字面量的定义方式
        String s2="hello";

        System.out.println(s1==s2);	//true
    }
}

既然它们都在常量池里面，也不能存放相同的，那就意味着它们是同一个，即地址是同一个。

若打印出来，地址是一样的，如下：

️内存结构图：

☕注意

• 字符串常量都存储在字符串常量池(StringTable)中。
• 字符串常量池不允许存放两个相同的字符串常量。
• 字符串常量池，在不同的jdk版本中，存放位置不同。
  • jdk7之前：字符串常量池存放在方法区。
  • jdk7及之后：字符串常量池存放在堆空间。

---

2、String的存储位置演进

内存图

看下面的内存图。

①JDK6当中：

字符串常量池和静态变量都存放在“方法区”中，方法区是Java虚拟机规范中的概念，也叫永久代。

②JDK7中：

字符串常量池和静态变量都存放在“堆”中。

③JDK8中：

字符串常量池和静态变量都存放在“堆”中。

为什么要将字符串常量池改放堆空间呢？

主要还是出于GC（垃圾回收行为）的考虑。

栈里面没有GC，只有入栈和出栈。堆空间和方法区都有GC。

从实际执行效果上来看，堆是一个需要频繁GC的场所，方法区很少进行GC，因为方法区主要加载类的一些信息，类不会轻易被回收。

为了及时回收字符串常量池的内存空间，就将它移到堆空间中。

方法区也改名了，从永久代改为元空间。

主要原因是JDK8开始，使用物理内存了，方法区回收效果也不好，干脆使用本地物理内存。

二、String的不可变性

（1）举例1

当对字符串变量重新赋值时，需要重新指定一个字符串常量的位置进行赋值，不能在原有的位置修改。

【举例1】

代码

//String的不可变性
@Test
public void test2(){
    //s1与s2指向同一个数据
    String s1="hello";
    String s2="hello";

    s2="h1";

    System.out.println(s1);	//hello
}

输出

️内存结构图：

当我们试图对hello进行修改，这时候不行，需要新建一个空间，原来的“hello”是不可变的。

（2）举例2

当对现有的字符串进行拼接操作时，需要重新开辟空间保存拼接以后的字符串，不能在原有的位置修改。

【举例2】

代码

    @Test
    public void test3() {
        //s1与s2指向同一个数据
        String s1 = "hello";
        String s2 = "hello";

        s2 += "world";

        System.out.println(s1);	//hello
        System.out.println(s2);	//helloworld
    }

输出

️内存结构图：

当我们想要在现有字符串的基础上拼接一个字符串的时候，需要重新开辟一个空间。

不能在原有基础上做修改。（原有位置不可变）

（3）举例3

当调用字符串的replace()替换现有的某个字符时，需要重新开辟空间保存修改以后的字符串，不能在原有的位置修改。

【举例3】

replace()：替换某个字符，返回String类型。（底层是新new了一个对象）

代码

@Test
public void test4() {
    String s1 = "hello";
    String s2 = "hello";

    String s3=s2.replace('l','w');    //将l替换为w

    System.out.println(s1); //hello
    System.out.println(s2); //hello
    System.out.println(s3); //hewwo
}

输出

️内存结构图：

不能改变在原有的字符串常量池中的“hello”，s1与s2还是hello。

（4）总结

代码

package String;

import org.junit.Test;

/**
 * ClassName: StringDemo
 * Package: String
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/2/5 0005 14:48
 */
public class StringDemo {
    @Test
    public void test1() {
        String s1 = "hello";  //字面量的定义方式
        String s2 = "hello";

        System.out.println(s1 == s2);
    }

    //String的不可变性
    @Test
    public void test2() {
        //s1与s2指向同一个数据
        String s1 = "hello";
        String s2 = "hello";

        s2 = "h1";

        System.out.println(s1); //hello
    }

    @Test
    public void test3() {
        //s1与s2指向同一个数据
        String s1 = "hello";
        String s2 = "hello";

        s2 += "world";

        System.out.println(s1); //hello
        System.out.println(s2); //helloworld
    }

    @Test
    public void test4() {
        String s1 = "hello";
        String s2 = "hello";

        String s3=s2.replace('l','w');    //将l替换为w

        System.out.println(s1); //hello
        System.out.println(s2); //hello
        System.out.println(s3); //hewwo
    }
}

☕String的不可变性的理解：

① 当对字符串变量重新赋值时，需要重新指定一个字符串常量的位置进行赋值，不能在原有的位置修改。

② 当对现有的字符串进行拼接操作时，需要重新开辟空间保存拼接以后的字符串，不能在原有的位置修改。

③ 当调用字符串的replace()替换现有的某个字符时，需要重新开辟空间保存修改以后的字符串，不能在原有的位置修改。

三、String的内存结构

因为字符串对象设计为不可变，那么所以字符串有常量池来保存很多常量对象。

JDK6中，字符串常量池在方法区。JDK7开始，就移到堆空间，直到目前JDK17版本。

举例内存结构分配：