String类在内存中实现原理详解

（1）

==  比较引用类型比较的是地址值是否相同

equals:比较引用类型默认也是比较地址值是否相同，而String类重写了equals()方法，比较的是内容是否相同。

（2）

区分下面两种语句在内存中的实现：

<span style="font-size:14px;">String s=new String("abcde");
String s2="abcde";
System.out.println(s==s2);          //false
System.out.println(s.equals(s2));      //true</span>

① String s=new String("abcde")，首先在堆中new（新建）一个对象xx，在常量池中寻找是否已经含有“abcde”字符串，如果有，xx直接指向该字符串（实际是xx保存了该字符串在常量池中的地址）；否则，新创建“abcde”字符串，然后xx指向。   在栈中新建String类引用变量s，s指向堆中对象xx（即保存xx的地址值）。

②String s2=“abcde”；  首先去常量池中寻找“abcde”的字符串，找到，则栈中引用变量s2直接指向它；否则，新建“abcde”字符串，s2指向其。

综上，s指向的是堆内存中对象，s2指向的是常量池中的字符串“abcde”，故两者保存的地址不同

（3）

<span style="font-size:14px;">String s3=new String("abcdef");
String s4=new String("abcdef");
System.out.println(s3==s4);            //false
System.out.println(s3.equals(s4));     //true</span>

分析可知：s3、s4分别指向堆内存中不同的（通过new 创建的）对象x1，x2，即使x1、x2指向常量池中同一个字符串“abcdef ”，故s3、s4保存的地址不同

（4）

含有变量的字符串拼接，通过反编译可以知道，实际上是new了一个新对象，然后再拼接，在常量池中寻找、指向

通过new创建的对象，可以通过调用 intern（）方法，返回对象指向常量池中的引用（地址）

<span style="font-size:14px;">String s="hello ";
String s1="world";
String s3="hello world";

String s4=s+s1;
//s,s1是变量，变量相加在编译时，在堆中先new了一个空间，拼接s、s1，然后在常量池中寻找s+s1字符串，有则将
//new 的对象指向它，没有则创建字符串，再指向
//相当于 String s4=new String("hello world");

System.out.println(s3==s4);         //false
System.out.println(s4.intern()==s3); //true

String s10=new String(s+s1);
System.out.println(s10.intern()==s3);//true
System.out.println(s10.intern()==s4.intern()); //true

String s5="hello "+"world"; //字符串常量相加，先拼接，再在常量池中寻找，如果有，就直接指向该字符串，否则，就创建
System.out.println(s5==s3); //true
String s6=s+"world";
System.out.println(s6==s3); //false
System.out.println(s6==s4); //false
System.out.println("------------------");

String s7="abcd";
String s8=new String("abcd").intern();
//intern 方法可以返回该字符串在常量池中的对象的引用,即返回"abcd"在常量池中的引用

String s9=new String("abcd");
System.out.println(s7==s8); //true
System.out.println(s7==s9); //false</span>