equals和hashCode方法
equals
我们知道equals是用来比较两个对象是否相等的，比如我们常用的String.equals方法
@Test
public void test() {
String str1=new String("abc");
String str2=new String("abc");
boolean equals = str1.equals(str2);
System.out.println(equals);//true
}
hashCode方法
hashCode方法是通过一定的算法得到一个hash值，一般配合散列集合一起使用，如HashMap、HashSet都是不可以存放重复元素的，那么当容器中元素个数很多时，你要添加一个元素时，难道一个一个去equals比较？当然这是可以的，但是难免效率很低，而HashMap和HashSet的底层都是使用数组+链表的方式实现的，这样有什么好处呢，当一个对象要加入集合，直接用hashCode进行一些运算得到保存的数组下标，再去数组下标对应的链表中一个一个元素比较（equals）,这样显然减少了比较次数，提高了效率
那Object的hashCode方法的默认实现是怎样的呢？
public native int hashCode();
可以看到它是一个本地方法，实际上Object的hashCode方法返回是元素的地址（不同的虚拟机可能不一样，但Hotspot的是）
class Emp{
String idCord;
String name;
int age;
public Emp(String idCord, String name, int age) {
super();
this.idCord = idCord;
this.name = name;
this.age = age;
}
}
@Test
public void test2() {
Emp e=new Emp("0101001","zhangsan",20);
System.out.println(e.hashCode());//1717159510
System.out.println(e);//com.moyuduo.test.Emp@6659c656
}
6659c656转换成十进制也就是1717159510
哈希集合的使用
我们很多时候这样使用HashMap
@Test
public void test3() {
HashMap<String,Emp> map=new HashMap<>();
map.put(new String("zhangsan"), new Emp("01001","zhangsan",20));
map.put(new String("lisi"), new Emp("01002","lisi",22));
map.put(new String("zhangsan"), new Emp("01003","zhangsan",23));
Emp emp = map.get("zhangsan");
System.out.println(emp);//Emp [idCord=01003, name=zhangsan, age=23]
}
额？不对呀，编号为01001的张三呢？而且我们知道new出来的String的hashCode是地址一定是不相同的，那么为什么后一个张三还是把前一个张三覆盖了呢？
是因为String重写了hashCode方法和equals方法
public int hashCode() {
//默认为0
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
//一个一个遍历String的char[]
for (int i = 0; i < value.length; i++) {
//hash值等于当前字符前字符的hash*31+当前字符的Unicode
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
public boolean equals(Object anObject) {
//判断两个对象的地址是否相同
if (this == anObject) {
return true;
}
//判断传入的对象是不是String类型
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
//判断两个String的char[]的长度是否一致
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;
}
那么当我们使用自己的对象作为键时
@Test
public void test4() {
HashMap<Emp,Integer> map=new HashMap<>();
map.put(new Emp("01001","zhangsan",20),6000);
map.put(new Emp("01002","lisi",22),8000);
Integer integer = map.get(new Emp("01001","zhangsan",20));
System.out.println(integer);//null
}
可以看到输出的是null，这是为什么呢，就是因为我们自定义的类没有重新写hashCode方法，get的时候新new出来的Emp对象的hashCode（也就是地址）肯定和存的时候的hashCode不一样，所以拿不到，所以当我们自定义的类要使用散列集合存储时，一定要重写equals方法和hashCode方法
HashMap的底层原理
为什么当我们要使用自定义对象作为key存放在HashMap中时，一定要重写equals和hashCode呢？
我们去看看HashMap底层是怎么存键值对和得到值的
HashMap的put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//计算键的hash
static final int hash(Object key) {
int h;
//如果键为null那么hash为0，这也是为什么HashMap只能存放一个键为null的元素，否则hash为hashCode与上hashCode无符号右移16位
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果当前的Node数组还未初始化或长度为0
if ((tab = table) == null || (n = tab.length) == 0)
//进行扩容
n = (tab = resize()).length;
//节点存放的下标是数组长度-1与上键的hash
if ((p = tab[i = (n - 1) & hash]) == null)
//运算得到的下标的位置没有存放元素，那么直接保存
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//如果下标位置元素的hash和键的hash相等并且下标元素的key和键的地址相同或equals那么直接覆盖
e = p;
else if (p instanceof TreeNode)
//如果下标元素位置存放的元素本来就是红黑色节点,那么按照红黑树的规则插入
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else { //下标位置有元素而且还没转化为红黑树，说明是链表存储
for (int binCount = 0; ; ++binCount) {
//让e指向链表下一个节点
if ((e = p.next) == null) {//当找到最后e等于null了说明链表中没有元素的key和当前插入的key相同
//直接把节点挂到链表尾
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果找到已存入元素的key和插入key的hash相同并且两key地址相等或equals，那么e就是要替换的元素
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//替换旧值
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
//插入后元素大小超过阈值进行扩容
resize();
afterNodeInsertion(evict);
return null;
}
HashMap的get方法
public V get(Object key) {
Node<K,V> e;
//如果通过key拿到的键值对节点为null就返回null，否则返回节点的value
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//Node[]是否已经初始化并且长度>0并且通过hash运算得到的下标已经有元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//判断下标第一个位置节点的hash和查询key的hash一致并且两key地址一样或equals
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//下标节点还有next
if ((e = first.next) != null) {
//节点是红黑树，那么按照红黑树的查找规则进行
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
//是链表，那么依次遍历
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
可以看到存的时候是通过hashCode得到hash再用hash得到存放下标，然后存入键值对
取的时候是通过hashCode得到hash再得到下标元素，下标元素再根据hash&&（地址相等||equals）得到键值对
Object规范
说了这些再来说说Object规范
- 两对象equals那么hashCode值一定要相同
- 两对象hashCode值相等，对象不一定equals，这主要是因为hashCode是根据对象的特征值生成的，hashCode的算法是程序员自己实现的，在某些情况下可能两对象在逻辑上也不同也能生成相同的hashCode
equals和hashCode联系
- 当我们自定义类不需要充当key来在散列表中存储对象时，equals和hashCode根本没有关系，你也没必要重写hashCode方法
- 当我们会用自定义类充当key在散列表中存对象，这时候你一定要重写equals和hashCode