equals和hashcode
equals()：反映的是对象或变量具体的值，即两个对象里面包含的值--可能是对象的引用，也可能是值类型的值。
hashCode()：计算出对象实例的哈希码，并返回哈希码，又称为散列函数。根类Object的hashCode()方法的计算依赖于对象实例的D（内存地址），故每个Object对象的hashCode都是唯一的；当然，当对象所对应的类重写了hashCode()方法时，结果就截然不同了。
之所以有hashCode方法，是因为在批量的对象比较中，hashCode要比equals来得快，很多集合都用到了hashCode，比如HashTable。
两个obj，如果equals()相等，hashCode()一定相等。
两个obj，如果hashCode()相等，equals()不一定相等（Hash散列值有冲突的情况，虽然概率很低）。
所以：
可以考虑在集合中，判断两个对象是否相等的规则是：
第一步，如果hashCode()相等，则查看第二步，否则不相等;
第二步，查看equals()是否相等，如果相等，则两obj相等，否则还是不相等。
为什么要重写equals方法？
-------------------------------------------
因为Object的equal方法默认是两个对象的引用的比较，意思就是指向同一内存,地址则相等，否则不相等；如果你现在需要利用对象里面的值来判断是否相等，则重载equal方法。
说道这个地方我相信很多人会有疑问，相信大家都被String对象的equals()方法和"=="纠结过一段时间，当时我们知道String对象中equals方法是判断值的，而==是地址判断。
那照这么说equals怎么会是地址的比较呢？
那是因为实际上JDK中，String、Math等封装类都对Object中的equals()方法进行了重写。
我们先看看Object中equals方法的源码：
|
1
2
3
|
public boolean equals(Object obj) { return (this == obj); } |
我们都知道所有的对象都拥有标识(内存地址)和状态(数据)，同时“==”比较两个对象的的内存地址，所以说使用Object的equals()方法是比较两个对象的内存地址是否相等，即若object1.equals(object2)为true，则表示equals1和equals2实际上是引用同一个对象。虽然有时候Object的equals()方法可以满足我们一些基本的要求，但是我们必须要清楚我们很大部分时间都是进行两个对象的比较，这个时候Object的equals()方法就不可以了，所以才会有String这些类对equals方法的改写，依次类推Double、Integer、Math。。。。等等这些类都是重写了equals()方法的，从而进行的是内容的比较。希望大家不要搞混了。
改写equals时总是要改写hashcode
-------------------------------------------
java.lnag.Object中对hashCode的约定：
1. 在一个应用程序执行期间，如果一个对象的equals方法做比较所用到的信息没有被修改的话，则对该对象调用hashCode方法多次，它必须始终如一地返回同一个整数。
2. 如果两个对象根据equals(Object o)方法是相等的，则调用这两个对象中任一对象的hashCode方法必须产生相同的整数结果。
3. 如果两个对象根据equals(Object o)方法是不相等的，则调用这两个对象中任一个对象的hashCode方法，不要求产生不同的整数结果。但如果能不同，则可能提高散列表的性能。
根据上一个问题，实际上我们已经能很简单的解释这一点了，比如改写String中的equals为基于内容上的比较而不是内存地址的话，那么虽然equals相等，但并不代表内存地址相等，由hashcode方法的定义可知内存地址不同，没改写的hashcode值也可能不同。所以违背了第二条约定。
又如new一个对象，再new一个内容相等的对象，调用equals方法返回的true，但他们的hashcode值不同，将两个对象存入HashSet中，会使得其中包含两个相等的对象，因为是先检索hashcode值，不等的情况下才会去比较equals方法的。
其他：
Java编程使用HashSet添加对象时，由于要符合Set的特点（没顺序，不重复）所以必须重写equals方法和hashCode方法。
第一：
Set集合没有顺序，也不允许重复。
为什么要这样：模拟现实的集合。
这里的重复只是：对象的重复
何为对象的重复：指的就是同一个对象。
何为同一个对象：内存中，所在的内存编号一致。
内存编号的表示是什么：哈希码（哈希码一般是 类名 和 对象所在内存地址的十六进制数字表示 的组合）。
第二：
这种设置和实现中的矛盾在什么地方：
现实生活中只要属性相同，我们就认为那是同一个对象。
这与计算机比较同一个对象的方法不同（计算机使用内存地址，即哈希码）
于是，就需要重写equals方法和hashCode方法（&&）来让程序的运行结果符合现实生活
基本数据类型的实现类都已经重写了上面的两个方法。
第三：
为什么要重写equals方法和hashCode方法（技术实现原理）：
程序向HashSet中添加一个对象时，先用hashCode方法计算出该对象的哈希码。
比较：
（1），如果该对象哈希码与集合已存在对象的哈希码不一致，则该对象没有与其他对象重复，添加到集合中！
（2），如果存在于该对象相同的哈希码，那么通过equals方法判断两个哈希码相同的对象是否为同一对象（判断的标准是：属性是否相同）
1>，相同对象，不添加。
2>，不同对象，添加！
这时有两个疑问：
1，为什么哈希码相同了还有可能是不同对象？
2,为什么经过比较哈希码还需要借助equals方法判断？
答：
首先：
按照Object类的hashCode方法，是不可能返回两个相同的哈希码的。（哈希码唯一标志了对象）
然后：
Object类的hashCode方法返回的哈希码具有唯一性（地址唯一性），但是这样不能让程序的运行逻辑符合现实生活。（这个逻辑就是：属性相同的对象被看作同一个对象。）
为了让程序的运行逻辑符合现实生活，Object的子类重写了hashCode的方法（基本数据类型的实现类都已经重写了两个方法，自定义的类要软件工程 师自己重写。）
那么：
重写的宗旨是什么？
重写就是为了实现这样的目的：属性相同的不同对象在调用其hashCode方法后，返回的是同样的哈希码。
但是
我们在重写的时候，发现几乎所有的写法都无法避免一个bug：有一些属性不同的对象（当然是不同的对象），会返回相同的哈希码。（即 重码）
最后：
为了解决这个问题：在哈希码相同的时候，再用equals方法比较两个对象的对应属性是否相同，这样，确保了万无一失。
这样：上面两个问题得到解决。
下面给出一个属性不同但哈希码相同的例子：
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
class Person {
private String name;
private int id;
Person(String name,int id) {
this.name = name;
this.id = id;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setId(int id){
this.id = id;
}
public int getId(){
return id;
}
public int hashCode(){
return name.hashCode()+id; //使用字符串哈希值与Integer的哈希值的组合
//这样会产生重码，实际上重码率很高
}
public boolean equals(Object obj){
if(obj instanceof Person){ //
Person p = (Person)obj;
return(name.equals(p.name) && id == p.id);
}
return super.equals(obj);
}
}
public class TestHashSet2 {
public static void main(String[] args) {
Person p1 = new Person("a",1);
Person p2 = new Person("b",0);
Set set = new HashSet();
set.add(p1);
set.add(p2);
Iterator it = set.iterator();
while(it.hasNext()){
System.out.println(it.next().getName());
}
}
}
Tip：
hashCode不同时，则必为不同对象。hashCode相同时，根据equlas()方法判断是否为同一对象。
在HashSet，HashMap，HashTable中都存在该问题。
浙公网安备 33010602011771号