String.intern()-优快云博客

前言

今天在看到这样一道题的时候，不知道为什么两次调用方式不一样结果却不同，就在网上搜索答案，由此有了以下内容

String s1 = new StringBuilder("go").append("od").toString();
System.out.println(s1.intern() == s1); 
String s2 = new StringBuilder("ja").append("va").toString();
System.out.println(s2.intern() == s2);

在这里插入图片描述

为什么要介绍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])); // 11ms
            arr[i] = new String(String.valueOf(sample[i % sample.length])).intern();// 21ms
        }
        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()方法后程序运行时间有所增加。这是因为程序中每次都是用了new String后又进行intern()操作的耗时时间，但是不使用intern()占用内存空间导致GC的时间是要远远大于这点时间的。

深入认识intern()方法

JDK1.7后，常量池被放入到堆空间中，这导致intern()函数的功能不同。
举例如下：

String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2);
  
String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);

输出结果

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

再分别调整上面代码2.3行、7.8行的顺序：

String s = new String("1");
String s2 = "1";
s.intern();
System.out.println(s == s2);
 
String s3 = new String("1") + new String("1");
String s4 = "11";
s3.intern();
System.out.println(s3 == s4);

输出结果为：

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

下面依据上面代码对intern()方法进行分析：

JDK1.6

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

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

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

JDK1.7

针对JDK1.7以及以上的版本，我们将上面两段代码分开讨论。先看第一段代码的情况：
在这里插入图片描述
再把第一段代码贴一下便于查看：

String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2);
 
String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);

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

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

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

总结

String s1 = new StringBuilder("go").append("od").toString();
System.out.println(s1.intern() == s1);

s1.intern() == s1就是这样的情况。s1.intern()发现常量池中不存在“good”，因此指向了s1。 "good"在常量池中创建时，也就直接指向了s1了。所以 s1.intern() == s1返回true。所以谁都不搭理在堆空间中的s1了，所以都返回了false。

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

而"java"这个字符串比较特殊，有一个system类已经使用过java关键词，然后放到了常量池中。所以s2.intern()找到的是常量池中的这个"java"，s2.intern()==s1返回false。