String

最新推荐文章于 2024-11-04 20:33:37 发布

NocturneMK

最新推荐文章于 2024-11-04 20:33:37 发布

阅读量178

点赞数

文章标签：字符串 java jvm

本文链接：https://blog.csdn.net/qq_40820563/article/details/118058667

版权

原文 http://tangxman.github.io/2015/07/27/the-difference-of-java-string-pool/

String的应用无处不在，无论是算法题还是面试题，String都独占一方，甚至是无数面试者心中难以名状的痛。本文着重对String（若无特地说明，默认是JDK 1.8版本）常见的问题来进行介绍：

1. 字符串的不可变性

我们先来看看下面这段代码:

public class Test {
    public static void main(String[] args) {
        String str1 = new String("abc");
        String str2 = new String("abc");
        System.out.println("str1 == str2:" + str1 == str2);
    }
}

一般都能看出来，这运行结果肯定是false啊，可是为什么呢？
在解释之前，先介绍一下System.identityHashCode()：

System.identityHashCode()的作用是用来判断两个对象是否是内存中同一个对象，跟用==判断内存地址是否一样的效果一样。

System.out.println("str1:" + System.identityHashCode(str1));
System.out.println("str2:" + System.identityHashCode(str2));

从关键词new就可以看出，这两个String变量在堆上不可能是同一块内存。其表现（本图是基于JDK1.7，至于字符串常量池后文会介绍）：
在这里插入图片描述
那么如果加入以下代码，其输出结果会是怎么样的呢？

String str3 = str1;
System.out.println("str1 == str3:" + str1 == str3);
str3 += "ny";
System.out.println("str1 == str3:" + str1 == str3);

第一个结果为true，而第二个结果为false。显而易见，第二个结果出现不同是因为str3赋值为"ny"，那么这整个过程是怎么表现的呢？

当str3赋值为str1的时候，实际上是str3与str1指向同一块内存地址：

在这里插入图片描述

而str3赋值为str3+“ny"时，实际上是在常量池重新创建了一个新的常量"abcny”，并且赋予了不同的内存地址，即：

在这里插入图片描述

总结一下：字符串一旦创建，虚拟机就会在常量池里面为此字符串分配一块内存，所以它不能被改变。所有的字符串方法都是不能改变自身的，而是返回一个新的字符串。

如果需要改变字符串的话，可以考虑使用StringBuffer或StringBuilder来，否则每次改变都会创建一个新的字符串，很浪费内存。

2. 字符串常量池、Class常量池、运行时常量池

在Java的内存分配中经常听到关于常量池的描述，但名声最大的还是运行时常量池，对于字符串常量池和Class常量池近乎没有印象，甚至是混在一起，在此将这几个概念进行区分。

2.1 字符串常量池

在不知道这个名词之前，笔者以为字符串会跟类的其他信息一样存储在方法区（或永久代）中，但遇到它之后，笔者发觉这事情没那么简单。

我们来看看它和永久代的搬家史：

JDK 1.7之前，字符串常量池在永久代中
JDK 1.7，将字符串常量池移出了永久代，搬到了DataSegument中，一个在堆中一个相对特殊的位置（失去唯一引用也不会被回收）
JDK 1.8，永久代被元空间取代了

字符串常量池中的内容是在字符串对象实例的引用值（字符串常量池中存储的是引用值，具体的字符串对象实例存放在堆的另一块空间），而且在HotSpot VM中实现的字符串常量池是一个由C++实现的StringTable，结构跟Hashtable类似，但区别在于不能自动扩容。这个StringTable在每个HotSpot VM中是被所有的类共享的。

这么说可能有点抽象，不如使用HSDB来亲眼看看吧。举个栗子：

class NY{
    String str = "nyfor2020"; 
} 
public class Test {
    public static void main(String[] args) {
        NY ny1 = new NY();
        NY ny2 = new NY();
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    } 
}

在命令提示符中输入“jps”查看进程号后，在命令提示符中输入：

java -classpath “%JAVA_HOME%/lib/sa-jdi.jar” sun.jvm.hotspot.HSDB

打开HSDB，输入进程号后使用Object Histogram找到相应类之后，可以找到两个NY对象引用的字符串的地址是同一个。
在这里插入图片描述

2.2 Class常量池

在《深入理解Java虚拟机》中对Class常量池的介绍是从这里引入：

Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池（Constant Pool Table），用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后进入方法去的运行时常量池中存放。

字面量即常量概念，如文本字符串、被声明为final的常量值等。而符号引用即一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用的时候能直接定位到目标即可。

一般所说的类常量有以下三类：

类和接口的全限定名
字段的名称和描述符
方法的名称和描述符

关于常量池中的每一个常量表示什么含义在此就不赘述，想了解的朋友可以参考《深入理解Java虚拟机》的第六章。举个栗子：

public class Test {
    public static void main(String[] args) {
        String s1 = "nyfor2020";
    }
}

当我们使用以下命令进行反编译：

javap -verbose Test.class

在这里插入图片描述

在反编译之后我们可以直接看到Class常量池中的内容，有类的全限定名、方法的描述符和字段的描述符。

也就是说，当Java文件被编译成Class文件的过程之后，就会生成Class常量池。那么运行时常量池又是什么时候产生的呢？

2.3 运行时常量池

运行时常量池是方法区的一部分，用于存放Class文件编译后生成的Class常量池等信息。

接下来我们结合类加载过程来认识这几个常量池之间的关系：
在这里插入图片描述

在JVM进行类加载过程中必须经过加载、连接、初始化这三个阶段（在《Java的继承（深入版）》中有介绍），而连接过程又包括了验证、准备和解析这三个阶段。

当类加载到内存后，JVM就会将Class常量中的内容存放到运行时常量池中。而在Class常量池中存储的是字面量和符号引用，而非真正的对象实例，所以在经过解析之后，会将符号引用替换为直接引用，而在解析过程中会去查询字符串常量池，以保证运行时常量池所应用的字符串与字符串常量池中的信息一致。

3. String.intern()方法

在了解三个常量池之间的区别之后，我们来看看与字符串常量池有关的intern()方法.

/**
     * Returns a canonical representation for the string object.
     * <p>
     * A pool of strings, initially empty, is maintained privately by the
     * class {@code String}.
     * <p>
     * When the intern method is invoked, if the pool already contains a
     * string equal to this {@code String} object as determined by
     * the {@link #equals(Object)} method, then the string from the pool is
     * returned. Otherwise, this {@code String} object is added to the
     * pool and a reference to this {@code String} object is returned.
     * <p>
     * It follows that for any two strings {@code s} and {@code t},
     * {@code s.intern() == t.intern()} is {@code true}
     * if and only if {@code s.equals(t)} is {@code true}.
     * <p>
     * All literal strings and string-valued constant expressions are
     * interned. String literals are defined in p 3.10.5 of the
     * <cite>The Java&trade; Language Specification</cite>.
     *
     * @return  a string that has the same contents as this string, but is
     * guaranteed to be from a pool of unique strings.
     */
    public native String intern();

我们可以看到，intern()方法是一个本地方法，注释描述的大致意思是：

“当intern()方法被调用时，如果常量池中存在当前字符串，就会直接返回当前字符串；如果常量池中没有此字符串，会将此字符串放入常量池中后，再返回”。该方法的作用就是把字符串加载到常量池中。

刚刚在介绍字符串常量池时提到它在JDK 1.6和JDK 1.7的内存位置发生了变化，所以在不同版本的JDK中intern()方法的表现也有所差别。举个栗子：

public static void main(String[] args) {
    String str1 = new String("1") + new String("1");
    str1.intern();
    String str2 = "11";
    System.out.println(str1 == str2);
}

在JDK 1.6中的运行结果为false，在JDK 1.7中的运行结果为true。为什么会出现这种情况呢？主要是字符串常量池的内存位置变了，导致intern()的内部实现也发生了变化。

在JDK 1.6中的intern()
intern()方法将字符串复制到字符串常量池，然后返回一个该字符串在常量池的引用，但是str1并没接收到这个应用，所以str1指向的还是堆，但是str2指向的是常量区，所以这两个地址不一样。

在这里插入图片描述

在JDK 1.7中的intern()
在JDK 1.7中的intern()方法，（在字符串常量池找不到该字符串时）将该字符串对象在堆里的引用注册到常量池，以后在使用相同字面量声明的字符串对象则都指向该地址，也就是该字符串在堆中的地址。

等等，如果把intern()的位置下移一行之后呢？（基于JDK 1.7）

public static void main(String[] args) {
    String str1 = new String("1") + new String("1")
    String str2 = "11";
    str1.intern();
    System.out.println(str1 == str2);
    System.out.println(System.identityHashCode(str1));
    System.out.println(System.identityHashCode(str2));
}

运行结果为：

false
22307196
10568834

可以看到intern()的执行顺序改变之后，字符串常量池已经存储了"1"和"11"引用了，所以str2依然指向的是常量池中的引用，而str1指向的是new出来的字符串对象地址。

结语
在日常使用的时候，我们对于String的态度就像是对待空气，只有在出问题了才会发现之前没对它加以了解。此文以String问题为契机，对String相关原理进行回顾。

如果本文对你的学习有帮助，请给一个赞吧，这会是我最大的动力

参考资料

Java中String对象的不可变性

https://www.cnblogs.com/qingergege/p/5701011.html

在Java虚拟机中，字符串常量到底存放在哪

https://blog.csdn.net/weixin_34413802/article/details/88009934

了解JDK 6和JDK 7中substring的原理及区别

https://www.cnblogs.com/dsitn/p/7151624.html

java的replaceFirst和(反斜杠)[replace、replaceAll和replaceFirst的区别]

https://blog.csdn.net/lonfee88/article/details/7333883

String 重载 “+” 原理分析

https://blog.csdn.net/codejas/article/details/78662146

字符串拼接的几种方式和区别

https://www.cnblogs.com/lujiahua/p/11408689.html

Java—String.valueof()和Integer.toString()的不同

https://blog.csdn.net/whp1473/article/details/79935082

java switch是如何支持String类型的？

https://blog.csdn.net/guohengcook/article/details/81267768

JVM | 运行时常量池和字符串常量池及 intern()

https://hacpai.com/article/1581300080734

Java中几种常量池的区分

http://tangxman.github.io/2015/07/27/the-difference-of-java-string-pool/

String Buider 在什么条件下、如何使用效率更高？

编译器会将 String 拼接优化成使用 StringBuilder，但是还是有一些缺陷的。主要体现在循环内使用字符串拼接，编译器不会创建单个 StringBuilder 以复用
对于多次循环内拼接一个字符串的需求：StringBuilder 很快，因为其避免了 n 次 new 对象、销毁对象的操作，n - 1 次将 StringBuilder 转换成 String 的操作
StringBuilder 拼接不适用于循环内每次拼接即用的操作方式。因为编译器优化后的 String 拼接也是使用 StringBuilder 两者的效率一样。后者写起来还方便…