新建String对象到底生成几个对象呢？下面将对其进行详细介绍
package com.jadyer.detail;
/**
* String对象与StringPool之间的是是非非
* @author 玄玉
*
*/
public class StringPoolTest {
public static void main(String[] args) {
//【执行完该行代码，会在内存中生成两个对象，二者的内容都是abc】
//第一个对象在StringPool中，第二个对象在Java堆内存中
//注意：这里的s不是对象，s是对象的地址，叫做引用，它指向的是堆内存中的对象
//而StringPool是java.lang.String类所特有的，由于经常要用到String类的对象
//所以JVM内部为了能够重复使用String对象，便专门使用一片内存空间缓冲已存在的String对象
//★补充★：字符串常量池的作用域是整个虚拟机中，某种意义上讲是一个工程中
//在生成字符串对象的时候，String的执行流程如下：
//它首先到StringPool中查找，是否存在内容为abc的对象
//如果此时StringPool中已经存在abc对象，那么它就不会在StringPool中创建abc对象了
//但由于该行代码是main()方法的第一行语句，所以此时StringPool中是空的，没有对象的
//于是它发现StringPool中没有内容为abc对象，接着它就会把abc对象放到StringPool中
//接下来它去执行new String("abc")构造方法
//我们知道：new关键字表示生成一个对象，这个对象是在Java的堆内存中的
//于是接下来它就在Java的堆内存中又生成一个内容为abc的对象
//这样就造成了StringPool中有一个abc对象，堆内存中也有一个abc对象
String s = new String("abc");
//【执行完该行代码，内存中不会生成新的对象】
//由于这里是通过直接给出字面值"abc"，而不是new的方式为字符串赋值
//所以这种情况下，Java首先会到StringPool中查找有没有内容为abc的字符串对象存在
//若发现StringPool中没有abc对象，便在StringPool中新创建一个abc对象，再将引用指向新创建的abc对象
//如果在StringPool中存在abc对象，那么它就不会在StringPool中生成新的字符串对象了
//转而它会使用已经存在的字符串对象，并且将s1这个引用指向StringPool中的abc对象
String s1 = "abc";
//【执行完该行代码，内存中一共有三个对象】
//执行过程中，它会首先查看一下StringPool中有没有abc对象存在
//结果发现：有。。那么接着它就不会在StringPool中创建新的abc对象
//由于它是通过new String("abc")方式为字符串赋值的
//我们知道：只要Java中有new操作的话，就表示它会生成一个新的对象
//我们知道：而不管new多少次，都是生成新的对象，并且新的对象永远都在Java堆内存中
//所以执行该行代码时，它在堆内存中又会生成一个新的abc对象，并将其引用地址赋给s2
String s2 = new String("abc");
/**
* 也就是说，在执行完前面的三行语句后，内存中共有三个对象
* 其中包含了StringPool中的一个对象和堆内存中的两个对象
*/
//对于Java中的==来说，它所比较的永远永远都是两个对象的内存地址
//换句话说，比较等号左右两边的两个引用是不是指向同样的一个对象
//对于那8个原生数据类型，==比较的是它们的字面值是不是一样的
//对于引用类型，则判断它们引用的地址是不是一样，即判断两个引用指向的是否是同样一个对象
//这里s、s1、s2分别指向三个不同的对象，这三个对象分别在内存中不同的地方
//所以s、s1、s2中任意两个使用==比较时，由于三者的内存地址均不同，故返回值都是false
System.out.println(s == s1);
System.out.println(s == s2);
System.out.println(s1 == s2);
System.out.println("~~~~~~飘逸的分隔线01~~~~~~");
System.out.println(s.equals(s1));
System.out.println(s.equals(s2));
System.out.println(s1.equals(s2));
System.out.println("~~~~~~飘逸的分隔线02~~~~~~");
/**
* ★当调用java.lang.String.intern()方法时★
* 若StringPool中已经包含一个等于此String对象的字符串，则返回StringPool中的字符串
* 否则，将此String对象添加到StringPool中，并返回StringPool中的此String对象的引用
*/
//【当调用s.intern()时】它首先会先查StringPool中是否存在内容为abc的对象
//结果发现：有。。这时它就会将s.intern()的返回值指向StringPool中的abc对象
//换句话说：s.intern()返回的是StringPool中的abc对象的地址，即与s1相等的值
//所以s == s.intern()的判断就相当于拿s和s1进行==判断，结果当然会返回false
//【当调用s1.intern()时】它还是会检查StringPool中是否存在内容为abc的对象
//结果发现：有。。这时它同样会将StringPool中abc对象的地址返回赋给s1.intern()的返回值
//而s1本身指向的就是StringPool中的abc对象，所以s1 == s1.intern()判断的结果即true
//【基于同样道理】s.intern()和s2.intern()的返回值都是StringPool中的abc对象的地址
//所以s.intern() == s2.intern()判断的结果亦为true
System.out.println(s == s.intern());
System.out.println(s1 == s1.intern());
System.out.println(s.intern() == s2.intern());
System.out.println("~~~~~~飘逸的分隔线03~~~~~~");
String hello = "hello";
String hel = "hel";
String lo = "lo";
//这种情况下，在使用加号操作时
//★如果★加号左右两边的操作数都是字面值(即常量值)的话
//那么它会将这两个字面值拼起来，并得到一个对象，然后检查StringPool中有没有该对象存在
//若StringPool中没有该对象的话，那么就把它放进去
//若StringPool中存在该对象的话，则不生成新的对象，而是直接返回StringPool中的该对象
//★如果★加号左右两边有一个操作数不是常量的话，即有一个是变量的话
//那么在将这两个操作数的值拼起来后，就不会检查StringPool而是直接在堆内存中生成新对象
//也就是说"hel" + "lo"最终会拼成"hello"，并且它返回的是StringPool中hello的地址
//【所以hello == "hel" + "lo"判断的结果即为true】
//而"hel" + lo最终也会拼成"hello"，但不同的是它所拼成的"hello"不是StringPool中的
//而是在Java堆内存中新生成的一个"hello"对象。既然一个在堆内存中，一个在StringPool中————————截至此处，有待商榷！！
//【所以二者肯定不是同一个对象，故hello == "hel" + lo判断的结果即为false】
//【同理hello == hel + lo判断的结果亦为false】
System.out.println(hello == "hel" + "lo");
System.out.println(hello == "hel" + lo);
System.out.println(hello == hel + lo);
}
}
控制台输出如下
false false false ~~~~~~飘逸的分隔线01~~~~~~ true true true ~~~~~~飘逸的分隔线02~~~~~~ false true true ~~~~~~飘逸的分隔线03~~~~~~ true false false
总结一下：
1、通过new关键字创建的对象是在堆上，与字符串常量池内存地址肯定不一样.
2、通过new String("sb"),如果在常量池中没有sb，则会新建这个sb对象放进去，然后再到堆中创建一个sb对象。这样就会有两个值均为sb的对象了。
3、通过直接赋值String s = 'sb',则会直接在常量池寻找是否存在这个sb，不存在则在常量池中创建，存在则直接返回这个sb在常量池中的内存地址，使引用变量s指向它。
4、String.intern()方法：'sb'.intern()，则会去常量池查询是否存在sb这个字符串对象，存在则直接返回内存地址，不存在则创建再返回内存地址，反正最后常量池中肯定会有这个sb字符串对象，而返回的结果也一定是常量池中的内存地址。