Java技术——String类的intern()方法

最新推荐文章于 2023-09-11 21:09:07 发布

Angel_Zhl

最新推荐文章于 2023-09-11 21:09:07 发布

阅读量345

点赞数 1

分类专栏： java语言知识点学习到新知识点文章标签：知识点 java String intern 常量池

java语言知识点同时被 2 个专栏收录

43 篇文章

订阅专栏

学习到新知识点

15 篇文章

订阅专栏

本文详细解析了Java中String的intern()方法的工作原理及在不同JDK版本间的实现差异，探讨了其如何帮助节省内存资源。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

0.概要

在 JAVA 语言中有8中基本类型和一种比较特殊的类型String。这些类型为了使他们在运行过程中速度更快，更节省内存，都提供了一种常量池的概念。常量池就类似一个JAVA系统级别提供的缓存。
8种基本类型的常量池都是系统协调的，String类型的常量池比较特殊。它的主要使用方法有两种：

直接使用双引号声明出来的String对象会直接存储在常量池中。
如果不是用双引号声明的String对象，可以使用String提供的intern方法。存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用。
1）

public class StringInternTest {  

    public static void main(String[] args) {  

        String str1 = new StringBuilder("chaofan").append("wei").toString();  
        System.out.println(str1.intern() == str1);  

        String str2 = new StringBuilder("ja").append("va").toString();  
        System.out.println(str2.intern() == str2);  
    }  
}

这里写图片描述
有图可知，当在jdk1.6中运行时，会得到两个false，而在jdk1.7中运行，会得到一个true和一个false。
产生的差异在于在jdk1.6中 intern 方法会把首次遇到的字符串实例复制到永久待（perm区）（常量池）中，并返回此引用；但在jdk1.7中，只是会把首次遇到的字符串实例的引用添加到常量池中（没有复制），并返回此引用。
所以在jdk1.7中执行上面代码，str1返回true是引用他们指向的都是str1对象（堆中）（池中不存在，返回原引用），而str2返回false是因为池中已经存在”java”了（关键词），所以返回的池的对象，因此不相等。
2）

String str1 = new String("SEU")+ new String("Calvin");      
System.out.println(str1.intern() == str1);   
System.out.println(str1 == "SEUCalvin");  
//str1.intern() == str1就是上面例子中的情况，str1.intern()发现常量池中不存在“SEUCalvin”，
//因此指向了str1。 "SEUCalvin"在常量池中创建时，也就直接指向了str1了。两个都返回true就理所当然啦。

JDK1.8 输出结果：true true

String str2 = "SEUCalvin";//新加的一行代码，其余不变  
String str1 = new String("SEU")+ new String("Calvin");      
System.out.println(str1.intern() == str1);   
System.out.println(str1 == "SEUCalvin");   
//str2先在常量池中创建了“SEUCalvin”，那么str1.intern()当然就直接指向了str2，你可以去验证它们两个是返回的true。
//后面的"SEUCalvin"也一样指向str2。所以谁都不搭理在堆空间中的str1了，所以都返回了false。

再运行，输出结果： true false

str1和str2没有任何关系，但是之所以前后两个结果不一样，主要是因为String 的intern（）的方法的作用。

1.为什么要介绍intern()方法？

intern()方法设计的初衷，就是重用String对象，以节省内存消耗。

static final int MAX = 100000;  
static final String[] arr = new String[MAX];  

public static void main(String[] args) throws Exception {  
    //为长度为10的Integer数组随机赋值  
    Integer[] sample = new Integer[10];  
    Random random = new Random(1000);  
    for (int i = 0; i < sample.length; i++) {  
        sample[i] = random.nextInt();  
    }  
    //记录程序开始时间  
    long t = System.currentTimeMillis();  
    //使用/不使用intern方法为10万个String赋值，值来自于Integer数组的10个数  
        for (int i = 0; i < MAX; i++) {  
            arr[i] = new String(String.valueOf(sample[i % sample.length]));  
            //arr[i] = new String(String.valueOf(sample[i % sample.length])).intern();  
        }  
        System.out.println((System.currentTimeMillis() - t) + "ms");  
        System.gc();  
}

这个例子也比较简单，就是为了证明使用intern()比不使用intern()消耗的内存更少。

先定义一个长度为10的Integer数组，并随机为其赋值，在通过for循环为长度为10万的String对象依次赋值，这些值都来自于Integer数组。两种情况分别运行，可通过Window —> Preferences –> Java –> Installed JREs设置JVM启动参数为-agentlib:hprof=heap=dump,format=b，将程序运行完后的hprof置于工程目录下。再通过MAT插件查看该hprof文件。
两次实验结果如下：
这里写图片描述

从运行结果来看，不使用intern()的情况下，程序生成了101762个String对象，而使用了intern()方法时，程序仅生成了1772个String对象。自然也证明了intern()节省内存的结论。

细心的同学会发现使用了intern()方法后程序运行时间有所增加。这是因为程序中每次都是用了new String后又进行intern()操作的耗时时间，但是不使用intern()占用内存空间导致GC的时间是要远远大于这点时间的。

2.深入认识intern()方法

JDK1.7后，常量池被放入到堆空间中，这导致intern()函数的功能不同。且看下面代码，为你解答。

String s = new String("1");  
s.intern();  
String s2 = "1";  
System.out.println(s == s2);  
//String s = newString("1")，生成了常量池中的“1” 和堆空间中的字符串对象。
//
//s.intern()，这一行的作用是s对象去常量池中寻找后发现"1"已经存在于常量池中了。
//
//String s2 = "1"，这行代码是生成一个s2的引用指向常量池中的“1”对象。
//
//结果就是 s 和 s2 的引用地址明显不同。因此返回了false。  
String s3 = new String("1") + new String("1");  
s3.intern();  
String s4 = "11";  
System.out.println(s3 == s4);  
//String s3 = new String("1") + newString("1")，这行代码在字符串常量池中生成“1” ，并在堆空间中生成s3引用指向的对象（内容为"11"）。注意此时常量池中是没有 “11”对象的。
//
//s3.intern()，这一行代码，是将 s3中的“11”字符串放入 String 常量池中，此时常量池中不存在“11”字符串，JDK1.6的做法是直接在常量池中生成一个 "11" 的对象。
//
//但是在JDK1.7中，常量池中不需要再存储一份对象了，可以直接存储堆中的引用。这份引用直接指向 s3 引用的对象，也就是说s3.intern() ==s3会返回true。
//
//String s4 = "11"， 这一行代码会直接去常量池中创建，但是发现已经有这个对象了，此时也就是指向 s3 引用对象的一个引用。因此s3 == s4返回了true。

输出结果：

JDK1.6以及以下：false false  
JDK1.7以及以上：false true

下面对intern()方法进行分析。

2.1JDK1.6

这里写图片描述
在JDK1.6中所有的输出结果都是 false，因为JDK1.6以及以前版本中，常量池是放在 Perm 区（属于方法区）中的，熟悉JVM的话应该知道这是和堆区完全分开的。

使用引号声明的字符串都是会直接在字符串常量池中生成的，而 new 出来的 String 对象是放在堆空间中的。所以两者的内存地址肯定是不相同的，即使调用了intern()方法也是不影响的。

intern()方法在JDK1.6中的作用是：比如String s = new String(“SEU_Calvin”)，再调用s.intern()，此时返回值还是字符串”SEU_Calvin”，表面上看起来好像这个方法没什么用处。但实际上，在JDK1.6中它做了个小动作：检查字符串池里是否存在”SEU_Calvin”这么一个字符串，如果存在，就返回池里的字符串；如果不存在，该方法会把”SEU_Calvin”添加到字符串池中，然后再返回它的引用。然而在JDK1.7中却不是这样的，后面会讨论。

2.7 JDK1.7

这里写图片描述

String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2);
//String s = newString("1")，生成了常量池中的“1” 和堆空间中的字符串对象。
//
//s.intern()，这一行的作用是s对象去常量池中寻找后发现"1"已经存在于常量池中了。
//
//String s2 = "1"，这行代码是生成一个s2的引用指向常量池中的“1”对象。
//
//结果就是 s 和 s2 的引用地址明显不同。因此返回了false。

String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);
System.out.println(s3.intern()==s3);
//String s3 = new String("1") + newString("1")，这行代码在字符串常量池中生成“1” ，并在堆空间中生成s3引用指向的对象（内容为"11"）。注意此时常量池中是没有 “11”对象的。
//
//s3.intern()，这一行代码，是将 s3中的“11”字符串放入 String 常量池中，此时常量池中不存在“11”字符串，JDK1.6的做法是直接在常量池中生成一个 "11" 的对象。
//
//但是在JDK1.7中，常量池中不需要再存储一份对象了，可以直接存储堆中的引用。这份引用直接指向 s3 引用的对象，也就是说s3.intern() ==s3会返回true。
//
//String s4 = "11"， 这一行代码会直接去常量池中创建，但是发现已经有这个对象了，此时也就是指向 s3 引用对象的一个引用。因此s3 == s4返回了true。

下面继续分析第二段代码：
这里写图片描述

String ss = new String("1");
String ss2 = "1";
ss.intern();
System.out.println(ss == ss2);

//String s = newString("1")，生成了常量池中的“1” 和堆空间中的字符串对象。
//
//String s2 = "1"，这行代码是生成一个s2的引用指向常量池中的“1”对象，但是发现已经存在了，那么就直接指向了它。
//
//s.intern()，这一行在这里就没什么实际作用了。因为"1"已经存在了。
//
//结果就是 s 和 s2 的引用地址明显不同。因此返回了false。

String ss3 = new String("1") + new String("1");
String ss4 = "11";
ss3.intern();
System.out.println(ss3 == ss4);
//    String s3 = new String("1") + newString("1")，这行代码在字符串常量池中生成“1” ，并在堆空间中生成s3引用指向的对象（内容为"11"）。注意此时常量池中是没有 “11”对象的。
//
//String s4 = "11"， 这一行代码会直接去生成常量池中的"11"。
//
//s3.intern()，这一行在这里就没什么实际作用了。因为"11"已经存在了。
//
//结果就是 s3 和 s4 的引用地址明显不同。因此返回了false。
//所以s.intern(),在前面和在后面是很重要的，在前面是指向 s3 引用对象的一个引用。
// 在后面的话，在常量池中已经存在，就没有意义了。

3.问题归纳。

1.第一个问题，为什么“String s = new String(“1”)”在堆空间和常量池中同时生成对象？
答:这个问题，String类型的常量池比较特殊。
它的主要使用方法有两种：直接使用双引号声明出来的String对象会直接存储在常量池中。
如果不是用双引号声明的String对象，可以使用String提供的intern方法。
intern 方法会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中。
所以，因为有引号，所以会直接存储字符串对象到常量池中。

2.问题2.2 String s3 = new String(“1”) + newString(“1”)；为什么只在堆空间生成“11”而没有在常量池中生成“11”？按“原文1”论述，只能理解为字符串连接操作生成对象和new一个对象的差异？？？
答:因为被引号引起来的只有”1”，所以只会生成”1”，常量池中存在的是直接用引号引起来的字符值，是不会计算”1”+”1”的结果然后存入常量池中的；但是new String(“1”)+new String(“1”)是会在内存中进行计算的。也就是说，常量池中存在的引号所引起来的常量在编译前就已经确定好的，但是new String(“1”)+new String(“1”)是在运行的时候在堆内存中动态生成的，两个个”1”和一个”11”。

转载