Java字符串的intern方法有何奥妙之处

学习背景

进入正文学习字符串的intern()方法之前，先给下这4个问题，看下自己是否都知道答案？

1、string s1 = “a” + “b”; //创建了几个对象？
2、string s2 = new string(“ab”); //创建了几个对象？
3、string s3 = new string(“a”) + new string(“b”); //创建了几个对象？
4、string s4= new string(“a”) + new string(“a”); s4.intern(); //创建了几个对象？

如果都清楚，恭喜你，大佬一枚，不用往下学习了，哈哈哈！
那如果不太确定或者需要加深自己的理解，建议进入正文一起来了解下吧！
当然，也可以拉到最后有答案！

string#intern()示例代码

先来执行一下string调用intern()方法的一段示例代码：

public class stringinterntest {
    public static void main(string[] args) {
        string reference1 = new string("a");
        reference1.intern();
        string reference2 = "a";
        system.out.println(reference1 == reference2);

        string reference3 = new string("a") + new string("a");
        reference3.intern();
        string reference4 = "aa";
        system.out.println(reference3 == reference4);
    }
}

jdk1.6 执行输出结果：

false
false

jdk1.7 执行输出结果：

false
true

大家可以先思考一下为什么结果是这样的？往下会具体介绍！

string##intern()源码

先来看一下intern()方法的jdk源码如下：

    /**
     * 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 section 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()是一个native本地方法，但是native具体实现源码已经被隐藏了，这是一个历史故事了，sun公司在jdk7开发期间，由于技术竞争和商业竞争陷入泥潭，无力再投入精力继续研发jdk，oracle半路杀出直接收购sun公司，oracle接管jdk的研发后，发版了自己的oracle jdk，oracle的native底层等很多源码就被隐藏了，不过oracle官方也声明openjdk和oracle jdk7及以后版本，源码几乎是一模一样的，想要了解native底层源码具体实现过程，可以下载开源的openjdk的源码进行查看。

openjdk官网：
github也开源啦：

例如string对应的openjdk底层源码主入口：jdk7\jdk\src\share\native\java\lang\string.c

java_java_lang_string_intern(jnienv *env, jobject this)
{
    return jvm_internstring(env, this);
}

native底层方法的实现，需要掌握c和c++的语法，学习门槛要求比较高，这里不是我们要学习的重点，不做具体介绍。

string#intern()方法作用

前面jdk源码intern()方法的英文注释已经说明了intern()方法的有具体用途了，网上也有很多说明，不过这里我以个人的理解以及话术简单概括下intern()方法的作用如下：

（1）只要调用string对象的intern()，都会去找到字符串常量池，然后判断string对象的字符串内容是否已经存在常量池中，不存在，则往字符串常量池中创建该字符串内容的对象（jdk6及之前）或创建新的引用并指向堆区已有对象地址（jdk7之后），存在则直接返回。

（2）jdk7时，字符串常量池从永久代脱离，迁移到堆区中，相比于jdk6，变化不只是字符串常量池迁移到堆区而已，另一个变化就是调用字符串对象的intern()方法，如果字符串常量池中不存在该字符串内容的对象，则不会再像jdk6直接往字符串常量池中创建该字符串内容的对象，而是创建一个新的引用并指向堆区已有对象地址，实现字符串常量池和堆区字符串共用的目的，效率更高。

jdk6 string#intern()执行说明

一张图介绍前面示例代码jdk6执行过程如下：

/**
 * jdk6 string#intern()执行说明
 */
public class stringinterntest {
    public static void main(string[] args) {
        //step6.1
        //创建了2个对象，分别是堆区的string对象和字符串常量池中的"a"对象，reference1引用指向在堆区中的对象地址
        string reference1 = new string("a");
        //step6.2
        //判断字符串常量池，是否该字符串"a"，此前，池中已经有该对象了，因此会返回池中的对象地址的引用
        reference1.intern();
        //step6.3
        //字符串常量池中已存在字符串"a"，因此reference2引用直接指向对象在字符串常量池中的地址
        string reference2 = "a";
        //reference1指向对象地址是在堆区，reference2指向对象地址是在永久代的常量池，显然不可能一样
        system.out.println(reference1 == reference2);

        //step6.4
        //创建了2个对象，分别是在堆区的string对象(内容是"aa")和字符串常量池中的"a"对象
        //reference3引用指向对象在堆区中的地址，这过程还会在堆区创建了两个无引用的"a"对象，这里不做讨论
        string reference3 = new string("a") + new string("a");
        //step6.5
        //判断永久代中的字符串常量池，是否存在该字符串"aa"，这里是首次出现，因此直接将字符串拷贝并放到池中
        reference3.intern();
        //step6.6
        //池中已存在该字符串，reference2引用直接指向对象在永久代字符串常量池中的地址
        string reference4 = "aa";
        //同样，reference3指向堆区地址，reference4指向永久代常量池中的地址，显然不可能一样
        system.out.println(reference3 == reference4);
    }
}

jdk7 string#intern()执行说明

一张图介绍前面示例代码jdk7执行过程如下：

/**
 * jdk1.7 string#intern()执行说明
 **/
public class stringinterntest {
    public static void main(string[] args) {
        //step7.1
        //创建了2个对象，分别是堆区的string对象和字符串常量池中的"a"对象，reference1引用指向在堆区中的对象地址
        string reference1 = new string("a");
        //step7.2
        //判断字符串常量池，是否该字符串"a"，此前，池中已经有该对象了，因此会返回池中的对象地址的引用
        reference1.intern();
        //step7.3
        //字符串常量池中已存在字符串"a"，因此reference2引用直接指向对象在字符串常量池中的地址
        string reference2 = "a";
        //reference1指向对象地址是在堆区，reference2指向对象地址是在堆区的字符串常量池，引用指向的对象地址不一样
        system.out.println( reference1 == reference2);

        //step7.4
        //创建了2个对象，分别是在堆区的string对象(内容是"aa")和字符串常量池中的"a"对象（注意并不会创建"aa"对象）
        //reference3引用指向对象在堆区中的地址，这过程还会在堆区创建了两个无引用的"a"对象，这里不做讨论
        string reference3 = new string("a") + new string("a");
        //step7.5
        //判断堆区的字符串常量池中，是否存在该字符串"aa"，显然这里是首次出现
        //但并不像jdk6会新建对象"aa"存储，而是存储指向堆区已有对象地址的一个新引用
        reference3.intern();
        //step7.6
        //指向池中已有该字符串的新引用，reference4引用直接指向字符串常量池中的这个新引用，新引用则指向堆区已有对象地址
        string reference4 = "aa";
        //reference4指向新引用，而新引用则指向堆区已有对象地址，跟reference3引用直接指向的对象地址是同一个
        system.out.println(reference3 == reference4);
    }

经典面试问题之创建了几个对象？

在实际的java面试当中，经常会被问到字符串创建了几个对象的问题，主要是考察学习者对于对象的实例化以及字符串常量池在jvm结构体系中是如何运行的，个人觉得比较常见问题，无法就是如下几个：

1、最简单的比如：string s1 = “a” + “b”;创建了几个对象？

答：最多1个，多个字符串常量相加会被编译器优化为一个字符串常量即"ab"，如果字符串常量池不存在，则创建该对象。

2、相对简单的比如：string s1 = new string(“ab”);创建了几个对象？

答：1个或2个，使用new实例化对象，必然会在堆区创建一个对象，另外一个就是如果在字符串常量池中不存在"ab"这个对象，则会创建这个"ab"常量对象。

3、稍微难一点的比如：string s2 = new string(“a”) + new string(“b”);创建了几个对象？

答：至少4个，最多6个
堆区的1个new stringbuilder()和2个new string()
还有1个是stringbuilder()的tostring()方法底层实现是new string(value, 0, count)
另外2个即"a"、"b"可能会在常量池新建对象
有的同学可能会有疑问，那这个tostring过程"ab"字符串不会在常量池中也创建吗？
答案是，不会，最后stringbuilder的tostring() 的调用，底层new string(value, 0, count) 并不会在字符串常量池中去创建"ab"对象。
两个new string相加会被优化为stringbuilder，可以通过javac和javap查看汇编指令如下：
javac interntest.java
javap -c interntest

public class com.justin.java.lang.interntest {
  public com.justin.java.lang.interntest();
    code:
       0: aload_0
       1: invokespecial #1                  // method java/lang/object."<init>":()v
       4: return

  public static void main(java.lang.string[]);
    code:
       0: new           #2                  // class java/lang/stringbuilder
       3: dup
       4: invokespecial #3                  // method java/lang/stringbuilder."<init>":()v
       7: new           #4                  // class java/lang/string
      10: dup
      11: ldc           #5                  // string a
      13: invokespecial #6                  // method java/lang/string."<init>":(ljava/lang/string;)v
      16: invokevirtual #7                  // method java/lang/stringbuilder.append:(ljava/lang/string;)ljava/lang/stringbuilder;
      19: new           #4                  // class java/lang/string
      22: dup
      23: ldc           #8                  // string b
      25: invokespecial #6                  // method java/lang/string."<init>":(ljava/lang/string;)v
      28: invokevirtual #7                  // method java/lang/stringbuilder.append:(ljava/lang/string;)ljava/lang/stringbuilder;
      31: invokevirtual #9                  // method java/lang/stringbuilder.tostring:()ljava/lang/string;
      34: astore_1
      35: return
}

最难的无非就是再调用intern()方法，比如：
string s3= new string(“a”) + new string(“b”);
s3.intern();创建了几个对象？

答：最少4个，最多7个
1个new stringbuilder()和2个new string
还有1个是stringbuilder()的tostring()方法底层实现是new string(value, 0, count)
另外"a"、“b"可能会在常量池新建对象
最后调用intern()方法时，会去字符串常量池，判断"ab"是否存在，不存在，jdk6时会创建"ab” 1个对象，jdk7则只创建"ab"的引用并指向堆区内容为"ab"的stringbuilder对象地址。

到此这篇关于java字符串的intern方法有何奥妙之处的文章就介绍到这了,更多相关java intern方法内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！