浅谈 java 中的 == 和 equals

java中的数据类型，可分为两类：

1. 基础数据类型：byte，char，boolean，short， int，float，long， double 。使用“==”比较的是他们的值
2. 复合数据类型（类）："=="比较的是他们在内存中的存放地址，所以，对于同一个new出来的对象，他们比较后的结果为true，否则比较后的结果为false。Java中所有类都是继承于Object这个基类，在Object中的基类定义了一个默认的equals的方法，默认的equals方法中，直接调用“==”，比较对象的内存地址。源码如下：

   public boolean equals(Object obj) {
       return (this == obj);
   }

   不同子类，可以重写此方法，进行两个对象的equals比较。在一些类库中，这个方法就被重写了，如String, Integer, Date，他们不再是比较类在堆中的 存放地址了。例如在String中重写的equals方法如下，主要：

   public boolean equals(Object anObject) {
           if (this == anObject) {
               return true;
           }
           if (anObject instanceof String) {
               String anotherString = (String) anObject;
               int n = value.length;
               if (n == anotherString.value.length) {
                   char v1[] = value;
                   char v2[] = anotherString.value;
                   int i = 0;
                   while (n-- != 0) {
                       if (v1[i] != v2[i])
                               return false;
                       i++;
                   }
                   return true;
               }
           }
           return false;
   }

   从代码中我们可以看出：1. String类的equals调用“==”比较地址，如果是同一个对象的引用，可知对象相等，返回true； 2. 如果不是同一对象，equals方法将会挨个比较两个字符串中的字符，完全相等才返回true，否则false。String类的==和equals方法比价复杂，在下面的实例中，我们就该方式进行一些案例解析。

实例1：

String s1 = "abc";
String s2 = "abc";
		
System.out.println("s1 == s2:" + (s1 == s2));	//true
System.out.println("s1.equals(s2):" + s1.equals(s2));	//true

我的理解是，常量池中会创建一个“abc”对象，而这个对象可以被共享。所以在java虚拟机栈中，局部变量s1和s2都是引用（referece类型，它不等同于对象本身，可能是一个指向对象其实地址的引用指针，也可能是指向一个代表对象的句柄或其它与此对象相关的位置）的对象是常量池中的“abc”对象，也就是说“==”比较的是常量池中的“abc”对象的地址，所以s1==s2为true，由于s1==s2为true，自然equals返回true。

实例2:

String s3 = new String("abc");
String s4 = new String("abc");
System.out.println("s3 == s4:" + (s3 == s4));	//false
System.out.println("s3.equals(s4):" + s3.equals(s4));	//true
System.out.println("s1 == s3:" + (s1 == s3));	//false
System.out.println("s1.equals(s3):" + s1.equals(s3));	//true

这个时候，不仅在常量池中会有一个“abc”对象，在 Java堆中会创建两个对象，这个时候，在 java虚拟机栈中，局部变量s3和s4分别引用了 Java堆中的两个不同的对象，两个不同对象的在堆中的地址也不一样，自然s3==s4为false，当时，字符串中的字符相等，所以equals是相等的。而在 java虚拟机栈中，局部变量s1引用的是常量池中的字符串对象，而s3引用的是堆中的字符串对象，所以s1==s3为false

实例3:

String str1 = "ab" + "cd";
String str2 = "abcd";
System.out.println("str1 == str2:" + (str1 == str2));	//true

这是由于常量的值在编译的时候就被确定了，在这里，“ab”和“cd”都是常量，因此变量str3的值在编译的时候也就可以确定，这时代码编译后的效果等同于：String str1 ＝ “abcd”，这个时候，str1和str2引用的都是常量池中的“abcd”

实例4:

String s6 = "b";
String s7 = "a" + s6;
String s67 = "ab";
System.out.println("s7 == s67:" + (s7 == s67));	//false

Java编译器对“String ＋ 基本类型／常量”是当作常量表达式来直接求值优化。运行期的两个String相加，会产生新的对象，存储在堆中，那么在 java虚拟机栈中，局部变量s7引用的是堆中对象，s67引用的是常量池中对象，二者地址当然不同。