String的Equals()和==比较

String的Equals()和==比较

　　常量池（Constant Pool）：指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。JVM虚拟机为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（String,Integer和 Floating point常量）和对其他类型，字段和方法的符号引用。对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的， 对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。

　　1、String s = "abc"; 

　　创建过程分析：在class文件被JVM装载到内存中，JVM会创建一块String Pool（String缓冲池）。当执行String s = “abc”;时，JVM首先在String Pool中查看是否存在字符串对象“abc”（如何查看呢？用equals()方法判断），如果已存在该对象，则不用创建新的字符串对象“abc”，而直接使用String Pool中已存在的对象“abc”，然后将引用s指向该对象；如果不存在该对象，则先在String Pool中创建一个新的字符串对象“abc”，然后将引用s指向String Pool中创建的新对象。 

　　注意：使用“字符串常量”引号创建的字符串对象时，在编译期就已经确定将该对象存储到String Pool中了。因此，String s = “abc”只会在编译期，在String Pool中创建一个对象。

　　2、String s = new String("abc"); 

　　创建过程分析：当执行String s = new String(“abc”);时，JVM首先在String Pool中查看是否存在字符串对象“abc”，如果不存在该对象，则先在String Pool中创建一个新的字符串对象“abc”，然后执行new String(“abc”)构造方法，在Heap里又创建一个新的字符串对象“abc”（new出来的对象都放在Heap里面），并将引用s指向Heap中创建的新对象；如果已存在该对象，则不用创建新的字符串对象“abc”，而直接使用String Pool中已存在的对象“abc”， 然后执行new String(“abc”)构造方法，在Heap里又创建一个新的字符串对象“abc”，并将引用s指向Heap中创建的新对象。 

　　注意：使用new String（“”）创建的字符串对象时，会在运行期创建新对象存储到Heap中。因此，new String（“abc”）创建字符串对象时，会创建2个对象，编译期在String Pool中创建一个，运行时Heap中创建一个。

示例代码：

　　

String a="hello"; //编译期间，以被存储字符串常量池
        String b=new String("hello"); //运行期间才会创建
        final String c="hello";  //编译期间已被存储字符串常量池
        String d="hel";
        String e="lo";
        String f=new String("lo");
        System.out.println(a==b);        //false
        System.out.println(a.equals(b));  //true
        System.out.println(a==c);         //true
        System.out.println(a.equals(c));  //true
        System.out.println(b==c);         //false
        System.out.println(b.equals(c));  //true
        System.out.println("******split*****");
        System.out.println(a==(d+f));        //false
        System.out.println(a.equals(d+f));  //true
        System.out.println(c==(d+f));        //false
        System.out.println(c.equals(d+f));  //true

注意代码：

　　1、对于有+号，并且有引用变量：

　　

String s1 = "abc";
String s2 = "def";
String s3 = "abcdef";
String s4 = "abc"+"def";
String s5 = s1 + "def";
String s6 = "abc"+s2;
String s7 = s1 + s2;
System.out.println(s3 == s4);
System.out.println(s3 == s5);
System.out.println(s3 == s6);
System.out.println(s3 == s7);
　　运行结果如下：
　　true
　　false
　　false
　　false
　　
结果说明：JVM对于有字符串引用存在的字符串"+"连接中，而引用的值在程序编译期是无法确定的，即s1 + “def”无法被编译器优化，只有在程序运行期来动态分配并将连接后的新地址赋给s5。 但是对于强制声明为final的除外，如下所示：
 final String s1 = "abc";
final String s2 = "def";
String s3 = "abcdef";
String s4 = "abc"+"def";
String s5 = s1 + "def";
String s6 = "abc"+s2;
String s7 = s1 + s2;
System.out.println(s3 == s4);
System.out.println(s3 == s5);
System.out.println(s3 == s6);
System.out.println(s3 == s7);  

运行结果如下： 
true 
true 
true 
true 

结果说明：例程3和例程4与例程2的区别是，例程3在字符串s1前加了final修饰，例程4在字符串s1和s2前都加了final修饰。对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。所以此时的s1 + “def”和"abc" + "def"效果是一样的。接着后面两个含引用的字符串连接，JVM会进行相同的处理。故上面程序后面三个的结果为true。 

2、对于方法调用的
public static void main(String args[]){
    String s1 = "abc";
    final String s2 = getDef();
    String s3 = "abcdef";
    String s4 = "abc"+s2;
    String s5 = s1 + s2;
    System.out.println(s3 == s4);
    System.out.println(s3 == s5);
}  

private static String getDef(){
    return "def";
}  

程序运行结果如下：
false
false
结果说明：JVM对于方法调用给字符串引用赋值的情况，引用指向字符串的值在编译期是无法确定的，只有在程序运行调用方法后，将方法的返回值“def”和“abc”动态连接并分配新地址赋值给s4，所以上述程序的结果都为false。

String s=new String("XYZ")+new String("XYZ");总共创建了四个对象

对于第一个new String("XYZ"),需要在StringPool中存储XYZ创建一个对象，构造函数创建一个对象

对于第二个new String("XYZ"),构造函数需要创建一个对象

最后两个字符串相加会再StringPool中再创建一个对象

因此总共创建了4个对象