Java中equals与== 的区别

首先介绍Java中的数据类型可分为两类：

1.基本数据类型，也称原始数据类型，byte,short,char,int,long,float,double,boolean 
  他们之间的比较，用等号（==）或者equals的结果都一样，,比较的是他们的值，同时也包括基本类型和包装类型的比较。

 例如：Integer  a =10 ,int b= 10;

 则 a==b 与 a.equals(b)的结果是一样的。

原因是：JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，

 API中这样写 ：this method returns true if and only ifx andy refer to the same object (x == y has the valuetrue). 所以其实底层还是用 == 在进行比较，且当且仅当 x 和y是同一个对象的时候，才会返回True。

但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。所以用equals才会得到True。

 

2.复合数据类型   当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。

 所以对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的。

 也就是说当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。

 

请注意下面这个例子：

1. public class Test {  
2.   
3.     public static void main(String[]args ){    
4.         int i = 128;  
5.         Integer i2 = 128;  
6.         Integer i3 = new Integer(128);  
7.         //Integer会自动拆箱为int，所以为true  
8.         System.out.println(i == i2);//true  
9.         System.out.println(i == i3);//true    
10.         System.out.println(i2 == i3);//false  堆对象和栈对象，对象之间比较，而自动拆箱后对象都转换为int比较值  
11.         System.out.println("----------------------");  
12.         Integer i5 = 127;//java在编译的时候,被翻译成-> Integer i5 = Integer.valueOf(127);  
13.         Integer i6 = 127;  
14.         System.out.println(i5 == i6);//true  
15. //        Integer i51 = 128;  
16. //        Integer i61 = 128;  
17. //        System.out.println(i51 == i61);//false   
18.         Integer i52=new Integer(126);  
19.         Integer i62=new Integer(126);  
20.         System.out.println(i52==i62);//false  堆中两个不同对象  
21.         System.out.println("----------------------");  
22.         Integer ii5 = new Integer(127);  
23.         System.out.println(i5 == ii5); //false  堆对象和栈对象，对象之间比较，  
24.         Integer i7 = new Integer(128);  
25.         Integer i8 = new Integer(128);  
26.         System.out.println(i7 == i8);  //false  <span style="line-height: 21.6px; font-family: tahoma, arial, sans-serif;">堆中两个不同对象</span>  
27.   
28.       
29.     }  
30.   
31. }  

public class Test {

	public static void main(String[]args ){  
        int i = 128;
        Integer i2 = 128;
        Integer i3 = new Integer(128);
        //Integer会自动拆箱为int，所以为true
        System.out.println(i == i2);//true
        System.out.println(i == i3);//true  
        System.out.println(i2 == i3);//false  堆对象和栈对象，对象之间比较，而自动拆箱后对象都转换为int比较值
        System.out.println("----------------------");
        Integer i5 = 127;//java在编译的时候,被翻译成-> Integer i5 = Integer.valueOf(127);
        Integer i6 = 127;
        System.out.println(i5 == i6);//true
//        Integer i51 = 128;
//        Integer i61 = 128;
//        System.out.println(i51 == i61);//false 
        Integer i52=new Integer(126);
        Integer i62=new Integer(126);
        System.out.println(i52==i62);//false  堆中两个不同对象
        System.out.println("----------------------");
        Integer ii5 = new Integer(127);
        System.out.println(i5 == ii5); //false  堆对象和栈对象，对象之间比较，
        Integer i7 = new Integer(128);
        Integer i8 = new Integer(128);
        System.out.println(i7 == i8);  //false  <span style="line-height: 21.6px; font-family: tahoma, arial, sans-serif;">堆中两个不同对象</span>

    
	}

}

 

 

也就是说：首先，8行和9行输出结果都为true,因为Integer和int比都会自动拆箱（jdk1.5以上）。

14行的结果为true,而17行则为false,很多人都不动为什么。其实java在编译Integer i5 = 127的时候,被翻译成-> Integer i5 = Integer.valueOf(127);所以关键就是看valueOf()函数了。只要看看valueOf()函数的源码就会明白了。JDK源码的valueOf函数式这样的：

 

 

1 public static Integer valueOf(int i) {
2         assert IntegerCache.high >= 127;
3         if (i >= IntegerCache.low && i <= IntegerCache.high)
4             return IntegerCache.cache[i + (-IntegerCache.low)];
5         return new Integer(i);
6     }

 

 

看一下源码大家都会明白，对于-128到127之间的数，会进行缓存，Integer i5 = 127时，会将127进行缓存，下次再写Integer i6 = 127时，就会直接从缓存中取，就不会new了。所以22行的结果为true,而25行为false。(自动装箱时才会发生，Integer a=value，这种栈对象形式（类似　string str="abc"），如果Integer b= new Integer(value),则不会，分别在堆中建立对象)

对于23行和26行，因为对象不一样，所以为false。

对于以上的情况总结如下：

  ①无论如何，Integer与new Integer不会相等(栈对象，堆对象)。不会经历拆箱过程，i3的引用指向堆，而i4指向专门存放他的内存（常量池），他们的内存地址不一样，所以为false。
  ②两个都是非new出来的Integer（两个栈对象，涉及自动装箱），如果数在-128到127之间，则是true,否则为false
  java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存。
  ③两个都是new出来的,都为false（两个堆对象）。
  ④int和integer(无论new否)比（Integer涉及自动拆箱），都为true，因为会把Integer自动拆箱为int再去比。