String类的Intern()方法

首先我们先来看一段程序：
public class test01 {
	public static void  main(String args[]) {

		//String str2 = "JasonZhang";
		String str1 = new String("Jason")+ new String("Zhang");    
		System.out.println(str1.intern() == str1); 
		System.out.println(str1 == "JasonZhang");
	}
}
运行程序后，程序输出true，ture。
我们去掉注释再运行一次：
public class test01 {
	public static void  main(String args[]) {

		String str2 = "JasonZhang";
		String str1 = new String("Jason")+ new String("Zhang");    
		System.out.println(str1.intern() == str1); 
		System.out.println(str1 == "JasonZhang");
	}
}
程序输出了false，false。
这是怎么回事？
这是由于intern()方法重用String对象的结果，我们继续往下看。
public class test02 {

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

}

这个程序很简单，注释中已经标记了程序的运行结果，我们可以发现使用intern（）方法和不使用intern（）方法时程序所运行的时间差距十分明显，这也说明了使用intern()比不使用intern()消耗的内存更少。

 

 

需要注意的是自JDK1.7以后，常量池被放入到堆空间中，这导致intern()函数的功能不同，具体我们来看下面代码，这个例子广泛流传于网络：

public class test03 {
	/**
	 * 运行结果：
	 * JDK1.6以及以下：false false
	 * JDK1.7以及以上：false true
	 */
	public static void main(String[] args) {
		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);
	}
}
再调整一下代码的位置：

public class test04 {
	/**
	 * 运行结果：
	 * JDK1.6以及以下：false false
	 * JDK1.7以及以上：false false
	 */
	public static void main(String args[]) {
		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以及以前版本中，常量池是放在 Perm 区（属于方法区）中的，这是和堆区完全分开的。（见下图，图片来自《深入理解java虚拟机》）

 

 

我们知道使用引号声明的String字符串会直接在常量池中生成的，而 new 出来的 String 对象放在堆空间中。所以两者的内存地址是不相同的。当我们String s = new String("str")

，再调用s.intern()后，在JDK1.6中会检查字符串池里是否存在"str"字符串，如果存在，就返回池里的字符串；如果不存在，该方法会把"str"添加到字符串池中，然后再返回它的引用。

 

我们继续分析JDK1.7以后的程序输出内容：

public class test03 {
	/**
	 * 运行结果：
	 * JDK1.6以及以下：false false
	 * JDK1.7以及以上：false true
	 */
	
	public static void main(String[] args) {
		String s = new String("1");//生成了常量池中的“1” 和堆空间中的字符串对象s
		s.intern();//s对象去常量池中寻找后发现"1"已经存在于常量池中
		String s2 = "1";//生成一个s2的引用指向常量池中的“1”对象
		System.out.println(s == s2); //s 和 s2 的引用地址不同。因此返回了false
		 
		String s3 = new String("1") + new String("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。
		System.out.println(s3 == s4);//

	}

}


public class test04 {
	/**
	 * 运行结果：
	 * JDK1.6以及以下：false false
	 * JDK1.7以及以上：false false
	 */

	public static void main(String args[]) {
		String s = new String("1");//生成了常量池中的“1” 和堆空间中的字符串对象s
		String s2 = "1";//生成一个s2的引用指向常量池中的“1”对象，已经存在，直接指向它。
		s.intern();//这一行无实际作用。因为"1"已经存在了。
		System.out.println(s == s2); //s 和 s2 的引用地址不同。因此返回了false
		 
		String s3 = new String("1") + new String("1");在字符串常量池中生成“1” ，并在堆空间中生成s3引用指向的对象（内容为"11"）。注意此时常量池中是没有 “11”对象的
		String s4 = "11";//直接去生成常量池中的"11"
		s3.intern();//这一行无实际作用。因为"1"已经存在了。
		System.out.println(s3 == s4);//s3 和 s4 的引用地址不同。因此返回了false
		
	}
}

通过以上的讲解相信你已经对String的intern（）方法有了更深的理解。希望本文对你有帮助。