最近去面试了几家公司，被问到hashCode的作用，虽然回答出来了，但是自己还是对hashCode和equals的作用一知半解的，所以决定把它们研究一下。

以前写程序一直没有注意hashCode的作用，一般都是覆盖了equals，缺没有覆盖hashCode，现在发现这是埋下了很多潜在的Bug！今天就来说一说hashCode和equals的作用。

       先来试想一个场景，如果你想查找一个集合中是否包含某个对象，那么程序应该怎么写呢？通常的做法是逐一取出每个元素与要查找的对象一一比较，当发现两者进行equals比较结果相等时，则停止查找并返回true，否则，返回false。但是这个做法的一个缺点是当集合中的元素很多时，譬如有一万个元素，那么逐一的比较效率势必下降很快。于是有人发明了一种哈希算法来提高从该集合中查找元素的效率，这种方式将集合分成若干个存储区域（可以看成一个个桶），每个对象可以计算出一个哈希码，可以根据哈希码分组，每组分别对应某个存储区域，这样一个对象根据它的哈希码就可以分到不同的存储区域（不同的桶中）。如下图所示：

实际的使用中，一个对象一般有key和value，可以根据key来计算它的hashCode。假设现在全部的对象都已经根据自己的hashCode值存储在不同的存储区域中了，那么现在查找某个对象（根据对象的key来查找），不需要遍历整个集合了，现在只需要计算要查找对象的key的hashCode，然后找到该hashCode对应的存储区域，在该存储区域中来查找就可以了，这样效率也就提升了很多。说了这么多相信你对hashCode的作用有了一定的了解，下面就来看看hashCode和equals的区别和联系。

在研究这个问题之前，首先说明一下JDK对equals(Object obj)和hashCode()这两个方法的定义和规范：在Java中任何一个对象都具备equals(Object obj)和hashCode()这两个方法，因为他们是在Object类中定义的。 equals(Object obj)方法用来判断两个对象是否“相同”，如果“相同”则返回true，否则返回false。 hashCode()方法返回一个int数，在Object类中的默认实现是“将该对象的内部地址转换成一个整数返回”。 

下面是官方文档给出的一些说明：

 

   

    

   
   

    

     hashCode 的常规协定是：   
    
   

   

    

   
   

    

     在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。   
    
   

   

    

   
   

    

     如果根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。   
    
   

   

    

   
   

    

     以下情况不 是必需的：如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。   
    
   

   

    

   
   

    

     实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。）   
    
   

   

    

   
   

    
  
    
   

   

    

   
   

    

     当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
    
   
 

1.若重写了equals(Object obj)方法，则有必要重写hashCode()方法。

2.若两个对象equals(Object obj)返回true，则hashCode（）有必要也返回相同的int数。

3.若两个对象equals(Object obj)返回false，则hashCode（）不一定返回不同的int数。

4.若两个对象hashCode（）返回相同int数，则equals（Object obj）不一定返回true。

5.若两个对象hashCode（）返回不同int数，则equals（Object obj）一定返回false。

6.同一对象在执行期间若已经存储在集合中，则不能修改影响hashCode值的相关信息，否则会导致内存泄露问题。

  

    

     

    
    

     

        public boolean add(E e) {
     
    

    

     

    
    

     
	
      return map.put(e, PRESENT)==
      null;
     
    

    

     

    
    

     

          }
     
    
  

  

    

     

    
    

     

          public V put(K key, V value) {
     
    

    

     

    
    

     
        
      if (key == 
      null)
     
    

    

     

    
    

     
            
      return putForNullKey(value);
     
    

    

     

    
    

     
        
      int hash = hash(key.hashCode());
     
    

    

     

    
    

     
        
      int i = indexFor(hash, table.length);
     
    

    

     

    
    

     
        
      for (Entry<K,V> e = table[i]; e != 
      null; e = e.next) {
     
    

    

     

    
    

     

                  Object k;
     
    

    

     

    
    

     
            
      if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
     
    

    

     

    
    

     

                      V oldValue = e.value;
     
    

    

     

    
    

     

                      e.value = value;
     
    

    

     

    
    

     

                      e.recordAccess(
      this);
     
    

    

     

    
    

     
                
      return oldValue;
     
    

    

     

    
    

     

                  }
     
    

    

     

    
    

     

              }
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     

              modCount++;
     
    

    

     

    
    

     

              addEntry(hash, key, value, i);
     
    

    

     

    
    

     
        
      return 
      null;
     
    

    

     

    
    

     

          }
     
    
  

最后再来看几个测试的例子吧：

测试一：覆盖equals（Object obj）但不覆盖hashCode（）,导致数据不唯一性

 

   

    

   
   

    

     public class HashCodeTest {
    
   

   

    

   
   

    
	
     public static void main(String[] args) {
    
   

   

    

   
   

    

     		Collection set = 
     new HashSet();
    
   

   

    

   
   

    

     		Point p1 = 
     new Point(
     1, 
     1);
    
   

   

    

   
   

    

     		Point p2 = 
     new Point(
     1, 
     1);
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     		System.out.println(p1.equals(p2));
    
   

   

    

   
   

    

     		set.add(p1);   
     //(1)
    
   

   

    

   
   

    

     		set.add(p2);   
     //(2)
    
   

   

    

   
   

    

     		set.add(p1);   
     //(3)
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     		Iterator iterator = set.iterator();
    
   

   

    

   
   

    
		
     while (iterator.hasNext()) {
    
   

   

    

   
   

    

     			Object object = iterator.next();
    
   

   

    

   
   

    

     			System.out.println(object);
    
   

   

    

   
   

    

     		}
    
   

   

    

   
   

    

     	}
    
   

   

    

   
   

    

     }
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     class Point {
    
   

   

    

   
   

    
	
     private 
     int x;
    
   

   

    

   
   

    
	
     private 
     int y;
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    
	
     public Point(int x, int y) {
    
   

   

    

   
   

    
		
     super();
    
   

   

    

   
   

    
		
     this.x = x;
    
   

   

    

   
   

    
		
     this.y = y;
    
   

   

    

   
   

    

     	}
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    
	
     @Override
    
   

   

    

   
   

    
	
     public boolean equals(Object obj) {
    
   

   

    

   
   

    
		
     if (
     this == obj)
    
   

   

    

   
   

    
			
     return 
     true;
    
   

   

    

   
   

    
		
     if (obj == 
     null)
    
   

   

    

   
   

    
			
     return 
     false;
    
   

   

    

   
   

    
		
     if (getClass() != obj.getClass())
    
   

   

    

   
   

    
			
     return 
     false;
    
   

   

    

   
   

    

     		Point other = (Point) obj;
    
   

   

    

   
   

    
		
     if (x != other.x)
    
   

   

    

   
   

    
			
     return 
     false;
    
   

   

    

   
   

    
		
     if (y != other.y)
    
   

   

    

   
   

    
			
     return 
     false;
    
   

   

    

   
   

    
		
     return 
     true;
    
   

   

    

   
   

    

     	}
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    
	
     @Override
    
   

   

    

   
   

    
	
     public String toString() {
    
   

   

    

   
   

    
		
     return 
     "x:" + x + 
     ",y:" + y;
    
   

   

    

   
   

    

     	}
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     }
    
   

   

    

   
   

    

   
 

输出结果：

 

   

    

   
   

    

     true
    
   

   

    

   
   

    

     x:
     1,y:
     1
    
   

   

    

   
   

    

     x:
     1,y:
     1
    
   

   

    

   
   

    

   
 

（1）当执行set.add(p1)时（1），集合为空，直接存入集合；

（2）当执行set.add(p2)时（2），首先判断该对象（p2）的hashCode值所在的存储区域是否有相同的hashCode，因为没有覆盖hashCode方法，所以jdk使用默认Object的hashCode方法，返回内存地址转换后的整数，因为不同对象的地址值不同，所以这里不存在与p2相同hashCode值的对象，因此jdk默认不同hashCode值，equals一定返回false，所以直接存入集合。

 （3）当执行set.add(p1)时（3），时，因为p1已经存入集合，同一对象返回的hashCode值是一样的，继续判断equals是否返回true，因为是同一对象所以返回true。此时jdk认为该对象已经存在于集合中，所以舍弃。

测试二：覆盖hashCode方法，但不覆盖equals方法，仍然会导致数据的不唯一性

修改Point类：

 

   

    

   
   

    

     class Point {
    
   

   

    

   
   

    
	
     private 
     int x;
    
   

   

    

   
   

    
	
     private 
     int y;
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    
	
     public Point(int x, int y) {
    
   

   

    

   
   

    
		
     super();
    
   

   

    

   
   

    
		
     this.x = x;
    
   

   

    

   
   

    
		
     this.y = y;
    
   

   

    

   
   

    

     	}
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    
	
     @Override
    
   

   

    

   
   

    
	
     public int hashCode() {
    
   

   

    

   
   

    
		
     final 
     int prime = 
     31;
    
   

   

    

   
   

    
		
     int result = 
     1;
    
   

   

    

   
   

    

     		result = prime * result + x;
    
   

   

    

   
   

    

     		result = prime * result + y;
    
   

   

    

   
   

    
		
     return result;
    
   

   

    

   
   

    

     	}
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    
	
     @Override
    
   

   

    

   
   

    
	
     public String toString() {
    
   

   

    

   
   

    
		
     return 
     "x:" + x + 
     ",y:" + y;
    
   

   

    

   
   

    

     	}
    
   

   

    

   
   

    
 
    
   

   

    

   
   

    

     }
    
   

   

    

   
   

    

   
 

 

   

    

   
   

    

     false
    
   

   

    

   
   

    

     x:
     1,y:
     1
    
   

   

    

   
   

    

     x:
     1,y:
     1
    
   
 

原因分析：

（1）当执行set.add(p1)时（1），集合为空，直接存入集合；

（2）当执行set.add(p2)时（2），首先判断该对象（p2）的hashCode值所在的存储区域是否有相同的hashCode，这里覆盖了hashCode方法，p1和p2的hashCode相等，所以继续判断equals是否相等，因为这里没有覆盖equals，默认使用'=='来判断，所以这里equals返回false，jdk认为是不同的对象，所以将p2存入集合。

 （3）当执行set.add(p1)时（3），时，因为p1已经存入集合，同一对象返回的hashCode值是一样的，并且equals返回true。此时jdk认为该对象已经存在于集合中，所以舍弃。

  

    

     

    
    

     

      public class HashCodeTest {
     
    

    

     

    
    

     
	
      public static void main(String[] args) {
     
    

    

     

    
    

     

      		Collection set = 
      new HashSet();
     
    

    

     

    
    

     

      		Point p1 = 
      new Point(
      1, 
      1);
     
    

    

     

    
    

     

      		Point p2 = 
      new Point(
      1, 
      2);
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     

      		set.add(p1);
     
    

    

     

    
    

     

      		set.add(p2);
     
    

    

     

    
    

     
		
     
    

    

     

    
    

     

      		p2.setX(
      10);
     
    

    

     

    
    

     

      		p2.setY(
      10);
     
    

    

     

    
    

     
		
     
    

    

     

    
    

     

      		set.remove(p2);
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     

      		Iterator iterator = set.iterator();
     
    

    

     

    
    

     
		
      while (iterator.hasNext()) {
     
    

    

     

    
    

     

      			Object object = iterator.next();
     
    

    

     

    
    

     

      			System.out.println(object);
     
    

    

     

    
    

     

      		}
     
    

    

     

    
    

     

      	}
     
    

    

     

    
    

     

      }
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     

      class Point {
     
    

    

     

    
    

     
	
      private 
      int x;
     
    

    

     

    
    

     
	
      private 
      int y;
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
	
      public Point(int x, int y) {
     
    

    

     

    
    

     
		
      super();
     
    

    

     

    
    

     
		
      this.x = x;
     
    

    

     

    
    

     
		
      this.y = y;
     
    

    

     

    
    

     

      	}
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
	
      public int getX() {
     
    

    

     

    
    

     
		
      return x;
     
    

    

     

    
    

     

      	}
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
	
      public void setX(int x) {
     
    

    

     

    
    

     
		
      this.x = x;
     
    

    

     

    
    

     

      	}
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
	
      public int getY() {
     
    

    

     

    
    

     
		
      return y;
     
    

    

     

    
    

     

      	}
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
	
      public void setY(int y) {
     
    

    

     

    
    

     
		
      this.y = y;
     
    

    

     

    
    

     

      	}
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
	
      @Override
     
    

    

     

    
    

     
	
      public int hashCode() {
     
    

    

     

    
    

     
		
      final 
      int prime = 
      31;
     
    

    

     

    
    

     
		
      int result = 
      1;
     
    

    

     

    
    

     

      		result = prime * result + x;
     
    

    

     

    
    

     

      		result = prime * result + y;
     
    

    

     

    
    

     
		
      return result;
     
    

    

     

    
    

     

      	}
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
	
      @Override
     
    

    

     

    
    

     
	
      public boolean equals(Object obj) {
     
    

    

     

    
    

     
		
      if (
      this == obj)
     
    

    

     

    
    

     
			
      return 
      true;
     
    

    

     

    
    

     
		
      if (obj == 
      null)
     
    

    

     

    
    

     
			
      return 
      false;
     
    

    

     

    
    

     
		
      if (getClass() != obj.getClass())
     
    

    

     

    
    

     
			
      return 
      false;
     
    

    

     

    
    

     

      		Point other = (Point) obj;
     
    

    

     

    
    

     
		
      if (x != other.x)
     
    

    

     

    
    

     
			
      return 
      false;
     
    

    

     

    
    

     
		
      if (y != other.y)
     
    

    

     

    
    

     
			
      return 
      false;
     
    

    

     

    
    

     
		
      return 
      true;
     
    

    

     

    
    

     

      	}
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     
	
      @Override
     
    

    

     

    
    

     
	
      public String toString() {
     
    

    

     

    
    

     
		
      return 
      "x:" + x + 
      ",y:" + y;
     
    

    

     

    
    

     

      	}
     
    

    

     

    
    

     
 
     
    

    

     

    
    

     

      }
     
    

    

     

    
    

     

    
  

  

    

     

    
    

     

      x:1,y:1
     
    

    

     

    
    

     

      x:
      10,y:
      10
     
    
  

理解：

规范1：若重写equals(Object obj)方法，有必要重写hashcode()方法，确保通过equals(Object obj)方法判断结果为true的两个对象具备相等的hashcode()返回值。说得简单点就是：“如果两个对象相同，那么他们的hashcode应该 相等”。不过请注意：这个只是规范，如果你非要写一个类让equals(Object obj)返回true而hashcode()返回两个不相等的值，编译和运行都是不会报错的。不过这样违反了Java规范，程序也就埋下了BUG。

规范2：如果equals(Object obj)返回false，即两个对象“不相同”，并不要求对这两个对象调用hashcode()方法得到两个不相同的数。说的简单点就是：“如果两个对象不相同，他们的hashcode可能相同”。

根据这两个规范，可以得到如下推论： 1、如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等。

2、如果两个对象不equals，他们的hashcode有可能相等。

3、如果两个对象hashcode相等，他们不一定equals。

4、如果两个对象hashcode不相等，他们一定不equals。

应用及作用：

1. '=='是用来比较两个变量（基本类型和对象类型）的值是否相等的， 如果两个变量是基本类型的，那很容易，直接比较值就可以了。如果两个变量是对象类型的，那么它还是比较值，只是它比较的是这两个对象在栈中的引用（即地址）。 对象是放在堆中的，栈中存放的是对象的引用（地址）。由此可见'=='是对栈中的值进行比较的。如果要比较堆中对象的内容是否相同，那么就要重写equals方法了。

2. Object类中的equals方法就是用'=='来比较的，所以如果没有重写equals方法，equals和==是等价的。 通常我们会重写equals方法，让equals比较两个对象的内容，而不是比较对象的引用（地址）因为往往我们觉得比较对象的内容是否相同比比较对象的引用（地址）更有意义。

3. Object类中的hashCode是返回对象在内存中地址转换成的一个int值（可以就当做地址看）。所以如果没有重写hashCode方法，任何对象的hashCode都是不相等的。通常在集合类的时候需要重写hashCode方法和equals方法，因为如果需要给集合类（比如：HashSet）添加对象，那么在添加之前需要查看给集合里是否已经有了该对象，比较好的方式就是用hashCode。

4. 注意的是String、Integer、Boolean、Double等这些类都重写了equals和hashCode方法，这两个方法是根据对象的内容来比较和计算hashCode的。（详细可以查看jdk下的String.java源代码），所以只要对象的基本类型值相同，那么hashcode就一定相同。

5. equals()相等的两个对象，hashcode()一般是相等的，最好在重写equals()方法时，重写hashcode()方法； equals()不相等的两个对象，却并不能证明他们的hashcode()不相等。换句话说，equals()方法不相等的两个对象，hashcode()有可能相等。 反过来：hashcode()不等，一定能推出equals()也不等；hashcode()相等，equals()可能相等，也可能不等。在object类中，hashcode()方法是本地方法，返回的是对象的引用（地址值），而object类中的equals()方法比较的也是两个对象的引用（地址值），如果equals()相等，说明两个对象地址值也相等，当然hashcode()也就相等了。

有许多人学了很长时间的Java，但一直不明白hashCode方法的作用，我来解释一下吧。首先，想要明白hashCode的作用，你必须要先知道Java中的集合。　　总的来说，Java中的集合（Collection）有两类，一类是List，再有一类是Set。你知道它们的区别吗？前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。那么这里就有一个比较严重的问题了：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。    于是，Java采用了哈希表的原理。哈希（Hash）实际上是个人名，由于他提出一哈希算法的概念，所以就以他的名字命名了。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。如果详细讲解哈希算法，那需要更多的文章篇幅，我在这里就不介绍了。初学者可以这样理解，hashCode方法实际上返回的就是对象存储的物理地址（实际可能并不是）。   这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。   所以，Java对于eqauls方法和hashCode方法是这样规定的：

1、如果两个对象相同，那么它们的hashCode值一定要相同；

2、如果两个对象的hashCode相同，它们并不一定相同    上面说的对象相同指的是用eqauls方法比较。    你当然可以不按要求去做了，但你会发现，相同的对象可以出现在Set集合中。同时，增加新元素的效率会大大下降