Java中有一个String类,特别让人伤脑筋。因为它可以直接赋值,也可以new一下用构造器生成对象,还可以用加号拼接……这些不同的方式到底有什么区别?本文是个人学习的一些总结,也希望能用最通俗的语言让大家明白这个类。
字符串创建有两种方式,分别来看看这两种方式有何区别: 1. 字面量赋值创建:
String str1 = "hello";
String str2 = "hello";
String str3 = "world";
这样创建字符串,首先会去常量池里找有没有这个字符串,有就直接指向常量池的该字符串,没有就先往常量池中添加一个,再指向它。图解:
图解
2. 用new创建:
String str1 = new String("hello");
String str2 = new String("hello");
String str3 = new String("world");
new一个字符串时,做了两件事。首先在堆中生成了该字符串对象,然后去看常量池中有没有该字符串,如果有就不管了,没有就往常量池中添加一个。图解:
图解
所以当问到“执行上面那三行代码创建了几个对象”这样的问题就很简单了,堆中三个常量池中两个,总共是5个。
小结:这两种方式创建出来的,一个在堆中,一个在常量池中,所以它们之间用 == 比较肯定是false。
字符串可以直接用加号进行拼接,但是也有几种不同的情况。 1. 常量拼接
String str = "hello" + "world";
对于这种加号两边都是常量的,在编译阶段就会自动拼接,变成
String str = "helloworld";
所以就会去常量池找"helloworld",有就直接指向它,没有就在常量池创建再指向。
2. 有final的拼接:
final String str1 = "hello";
final String str2 = "world";
String str3 = str1 + str2;
因为final修饰的变量就是常量,所以在编译期直接会变成
String str3 = "hello" + "world";
再根据常量拼接规则可知最终就变成
String str3 = "helloworld";
3. 变量和常量拼接: 变量和常量拼接的时候,底层会调用StringBuilder的append方法生成新对象。
String str1 = "hello";
String str2 = str1 + "world";
str1显然是在常量池中的,world也是在常量池中的,然后调用append方法在堆中生成新对象"helloworld",str2就指向堆中的"helloworld"对象。所以这两条语句总共生成了3个对象,常量池中有"hello"和"world",堆中有"helloword"。
String str1 = new String("hello");
String str2 = str1 + "world";
首先会在堆中创建一个"hello",再把"hello"添加到常量池;然后会把"world"添加到常量池,拼接的时候,会在堆中创建一个"helloworld"。所以这两条语句总共创建了4个对象,堆中的"hello"、"helloworld"和常量池中的"hello"、"world"。
4. 变量和变量拼接: 变量和变量拼接,底层也会调用StringBuilder的append方法生成新对象。
String str1 = "hello";
String str2 = "world";
String str3 = str1 + str2;
这段代码,首先会有一个"hello"在常量池中,然后有个"world"在常量池,第三行代码会调用append方法,在堆中生成一个"helloworld"。所以总共有3个对象。
String str1 = "hello";
String str2 = new String("world");
String str3 = str1 + str2;
这段代码,首先在常量池中搞一个"hello",然后在堆中new一个"world",同时把"world"也搞到常量池中去,第三步拼接就会在堆中生成一个"helloworld"。所以总共有4个对象。
String str1 = new String("hello");
String str2 = new String("world");
String str3 = str1 + str2;
第一行代码创建了两个对象,堆中一个常量池一个,第二行代码也是一样,第三行代码就在堆中创建了一个"helloworld"。所以总共创建了5个对象。
1、Java 1.7以前: JDK 1.7以前,intern方法会把对象拷贝到常量池。看下面例子:
String str1 = new String("str")+new String("01");
str1.intern();
String str2 = "str01";
System.out.println(str2==str1);
图解上述代码:
图解
首先new String("str")
会在堆中创建str,同时添加到常量池;new String("01")
也是一样的,在堆中创建01,同时添加到常量池;然后两者拼接,底层用的append方法,在堆中生成一个str01;然后str1.intern()
,就把str01拷贝到常量池了;此时运行到String str2 = "str01"
,发现常量池中有了,所以直接指向常量池中的str01。最终str1指向堆中的str01对象,str2指向常量池的str01对象,所以结果是false。
String str1 = new String("str")+new String("01");
String str2 = "str01";
str1.intern();
System.out.println(str2==str1);
我们将第二三行代码调换顺序,看看情况有什么不同:
图解
换一下顺序,区别就在于执行到第二行代码的时候,常量池中就已经有str01了,所以再执行str1.intern()
的时候,就没有再进行拷贝了。最终还是str1指向堆中的str01,str2指向常量池的str01,所以结果还是false。
2、JDK1.7以后(包括1.7): 从JDK 1.7开始,intern方法做了些改变,进行拷贝的时候不是拷贝对象,而是拷贝地址值。看下面的例子:
String str1 = new String("str")+new String("01");
str1.intern();
String str2 = "str01";
System.out.println(str2==str1);
图解上述代码:
图解
第一步和JDK 1.7之前是一样的,现在堆中创建一个str,同时搞到常量池,再创建一个01,同时搞到常量池,然后拼接,在堆中生成对象str01;不同的就是str1.intern()
,这次拷贝的不是str01这个对象,而是把它的地址值搞到常量池中去了;然后执行String str2 = str01
的时候,去常量池找str01,发现常量池中有x001
地址值,刚好该地址值对应的就是要找的str01,就直接拿过来用。最终就是str1指向地址值为x001
的对象,str2也是指向地址值为x001
的对象,所以结果是true。
String str1 = new String("str")+new String("01");
String str2 = "str01";
str1.intern();
System.out.println(str2==str1);
同样将二三行代码换一下位置,看看是什么情况:
图解
第一步就不多说了,执行第二步时,往常量池中找str01,发现没有,那就添加一个;再执行str1.intern()
时,发现常量池中有str01了,就不进行地址值的拷贝了。最终str1指向堆中的str01,str2指向常量池的str01,所以结果是false。
String str1 = new String("str")+new String("01");
String str2 = "str01";
str1 = str1.intern();
System.out.println(str2==str1);
就是把例二的str1.intern()
改成str1 = str1.intern()
,看看会有什么变化:
图解
本来str1是指向堆中的str01的,然后重新将str1.intern()
赋给str1,str1.intern()
是指向常量池的,赋给str1后,所以此时str1也是指向常量池。所以结果就是true。
本文用图文形式讲了String的面试考点,特别要注意JDK版本不同intern方法的差异。还有就是常量池的位置到底在方法区还是在堆中还是在元空间,这个我也不是很清楚,网上搜索的答案也比较杂。以上内容如果有误,欢迎批评指正!