Java基础之equals，== 和 hashcode理解

equals ，== 和 hashcode的理解

Object类是类继承结构的基础，所以是每一个类的父类。所有的对象，包括数组，都实现了在Object类中定义的方法。

java.lang.Object类中有两个非常重要的方法：

public boolean equals(Object obj)

public int hashCode()

==与equals的关系？

== 是比较引用是否相等。上面我们说过equals是Object类的重要方法之一，是用来判断其他的对象是否和该对象相等。

equals()方法在object类中定义如下：

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

很明显在object类中== 与equals是等价的，但是在很多类中，例如String 、Math、Integer、Double等这些封装类在使用equals()方法时，已经覆盖了object类的equals()方法。

hashcode和equals的关系？

​ hashCode()方法给对象返回一个hash code值。为什么要使用hash code值，主要是出于提高效率。我们要比较两个个元素是否相等，会调用equals方法。假如一个集合里有1000个元素了，它就要调用1000次equals方法。这显然会大大降低效率。于是，Java采用了哈希表的原理。哈希（Hash）实际上是个人名，由于他提出一哈希算法的概念，所以就以他的名字命名了。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上，这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

Java对象的eqauls方法和hashCode方法是这样规定的：

If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
相等（相同）的对象必须具有相等的哈希码（或者散列码）。
It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.
两个对象的hashCode相同，它们并不一定相同。

相等（相同）的对象必须具有相等的哈希码（或者散列码）

​ 假如两个Java对象A和B，A和B相等（eqauls结果为true），但A和B的哈希码不同，则A和B存入HashMap时的哈希码计算得到的HashMap内部数组位置索引可能不同，那么A和B很有可能允许同时存入HashMap，显然相等/相同的元素是不允许同时存入HashMap，HashMap不允许存放重复元素。

两个对象的hashCode相同，它们并不一定相同

​ 不同对象的hashCode可能相同；假如两个Java对象A和B，A和B不相等（eqauls结果为false），但A和B的哈希码相等，将A和B都存入HashMap时会发生哈希冲突，也就是A和B存放在HashMap内部数组的位置索引相同这时HashMap会在该位置建立一个链接表，将A和B串起来放在该位置，显然，该情况不违反HashMap的使用原则，是允许的。当然，哈希冲突越少越好，尽量采用好的哈希算法以避免哈希冲突。

为什么要同时重写equals和hashcode？

首先我们知道在hashset中不允许出现重复对象，元素的位置也是不确定的。在hashset中又是怎样判定元素是否重复的呢？

规则是：

1.判断两个对象的hashCode是否相等。如果不相等，认为两个对象也不相等，完毕；如果相等，转入2

2.判断两个对象用equals运算是否相等。如果不相等，认为两个对象也不相等； 如果相等，认为两个对象相等

示例代码一：由于没有重写equals和hashcode导致set存入重复元素。

import java.util.HashSet;
public class Demo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Book book1 = new Book("JAVA详解","Tom");
		Book book2 = new Book("JAVA详解","Tom");
		System.out.printf("book1.equals(book2) : %s; book1(%d) book2(%d)\n", book1.equals(book2), book1.hashCode(), book2.hashCode());
		HashSet<Book> set = new HashSet<Book>();
		set.add(book1);
		set.add(book2);
		System.out.printf("set:%s\n", set);
	}
}
class Book{
	private String name;
	private String author;
	public Book(String name , String author ){
		this.name = name ;
		this.author = author ;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "(<<"+name+">>," + author + ")";
	}
}
//output
book1.equals(book2) : false; book1(705927765) book2(366712642)
set:[(<<JAVA详解>>,Tom), (<<JAVA详解>>,Tom)]

示例代码二：只是重写equals，不符合约束第一条，导致set存入重复元素

import java.util.HashSet;
public class Demo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Book book1 = new Book("JAVA详解","Tom");
		Book book2 = new Book("JAVA详解","Tom");
		System.out.printf("book1.equals(book2) : %s; book1(%d) book2(%d)\n", book1.equals(book2), book1.hashCode(), book2.hashCode());
		HashSet<Book> set = new HashSet<Book>();
		set.add(book1);
		set.add(book2);
		System.out.printf("set:%s\n", set);
		

	}

}
class Book{
	private String name;
	private String author;
	
	public Book(String name , String author ){
		this.name = name ;
		this.author = author ;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "(<<"+name+">>," + author + ")";
	}

	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		if ( obj == null ){
			return false;
		}
		if ( this == obj ){
			return true;
		}
		if( this.getClass() != obj.getClass()){
			return false;
		}
		Book book =(Book)obj;
		return this.name.equals(book.name) && this.author.equals(book.author);
	}	
}
//output
book1.equals(book2) : true; book1(705927765) book2(366712642)
set:[(<<JAVA详解>>,Tom), (<<JAVA详解>>,Tom)]

示例代码三：同时重写equals和hashcode，set没有存入重复元素

import java.util.HashSet;
public class Demo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Book book1 = new Book("JAVA详解","Tom");
		Book book2 = new Book("JAVA详解","Tom");
		System.out.printf("book1.equals(book2) : %s; book1(%d) book2(%d)\n", book1.equals(book2), book1.hashCode(), book2.hashCode());
		HashSet<Book> set = new HashSet<Book>();
		set.add(book1);
		set.add(book2);
		System.out.printf("set:%s\n", set);
		

	}

}
class Book{
	private String name;
	private String author;
	
	public Book(String name , String author ){
		this.name = name ;
		this.author = author ;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "(<<"+name+">>," + author + ")";
	}
	
	

	@Override
	public int hashCode() {
		// TODO Auto-generated method stub
		int  name = this.name.toUpperCase().hashCode();
		int author =this.author.toUpperCase().hashCode();
		return name *author;
	}

	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		if ( obj == null ){
			return false;
		}
		if ( this == obj ){
			return true;
		}
		if( this.getClass() != obj.getClass()){
			return false;
		}
		Book book =(Book)obj;
		return this.name.equals(book.name) && this.author.equals(book.author);
	}	
}
book1.equals(book2) : true; book1(-269343346) book2(-269343346)
set:[(<<JAVA详解>>,Tom)]

另外我们只重写hashcode时候，结果如下，hashset说明先后进行了hashcode和euqals比较，在两者均不相等才断定不是同一个元素。

book1.equals(book2) : false; book1(-269343346) book2(-269343346)
set:[(<<JAVA详解>>,Tom), (<<JAVA详解>>,Tom)]