[厉害了,我的JAVA基础](十一)hashCode与equals的区别与联系
2018-03-07 15:20
621 查看
参考链接:
http://darrenzhu.iteye.com/blog/1682179
http://blog.csdn.net/e01014165/article/details/52173927
因为如果只覆盖了equals而没有覆盖hashCode, 则两个不同的instance(实例) a和b虽然equals结果(业务逻辑上)相等,但却会有不同的hashcode,这样hashmap里面会同时存在a和b,而实际上我们需要hashmap里面只能保存其中一个,因为从业务逻辑方向看它们是相等的.
equals方法和hashCode方法如果不同时按你自己逻辑覆盖的话,HashMap就会出问题。比如你只覆盖了equals方法而没有覆盖hashCode方法,那么HashMap在第一步寻找链表的时候会出错,有同样值的两个对象Key1和Key2并不会指向同一个链表或桶,因为你没有提供自己的hashCode方法,那么就会使用Object的hashCode方法,该方法是根据内存地址来比较两个对象是否一致,由于Key1和Key2有不桶的内存地址,所以会指向不同的链表,这样HashMap会认为key2不存在,虽然我们期望Key1和Key2是同一个对象;反之如果只覆盖了hashCode方法而没有覆盖equals方法,那么虽然第一步操作会使Key1和Key2找到同一个链表,但是由于equals没有覆盖,那么在遍历链表的元素时,key1.equals(key2)也会失败(事实上Object的equals方法也是比较内存地址),从而HashMap认为不存在Key2对象,这同样也是不正确的。
· 要是类中覆盖了equals方法,那么就要根据具体的代码来确定equals方法的作用了,覆盖后一般都是通过对象的内容是否相等来判断对象是否相等。
1. 没有覆盖equals方法代码如下:
运行结果:
结果分析:Student类没有覆盖equals方法,stu1调用equals方法实际上调用的是Object的equals方法。所以采用对象内存地址是否相等来判断对象是否相等。因为是两个新对象所以对象的内存地址不相等,所以stu1.equals(stu2) 是false。
2. 覆盖equals方法(age和name属性)后的Student类:
让Student类其通过判断对象的内容是否相等来确定对象是否相等
运行结果:
结果分析:
因为Student两个对象的age和name属性相等,而且又是通过覆盖equals方法来判断的,所示stu1.equals(stu2) 为true。注意以上几次测试list和set的size都是2
通过上面代码的运行,我们知道equals方法已经生效。接下来我们再覆盖一下hashCode方法(通过age和name属性来生成hashcode)并不覆盖equals方法,其中Hash码是通过age和name生成的。
3. 覆盖hashCode后的Student类:
运行结果如下:
结果分析:
我们并没有覆盖equals方法只覆盖了hashCode方法,两个对象虽然hashCode一样,但在将stu1和stu2放入set集合时由于equals方法比较的两个对象是false,所以就没有在比较两个对象的hashcode值。
4. 覆盖equals方法和hashCode方法
运行结果如下:
结果分析:
stu1和stu2通过equals方法比较相等,而且返回的hashCode值一样,所以放入set集合中时只放入了一个对象。
5. 覆盖equals方法和hashCode方法,但让hashCode的值不相等
运行结果如下:
结果分析:
虽然stu1和stu2通过equals方法比较相等,但两个对象的hashcode的值并不相等,所以在将stu1和stu2放入set集合中时认为是两个不同的对象。
6.修改stu1的某个属性值
运行结果如下:
结果分析:
当我们将某个对象存到set中时,如果该对象的属性参与了hashcode的计算,那么以后就不能修改该对象参与hashcode计算的那些属性了,否则会引起意向不到的错误的。正如测试中,不能够移除stu1对象
2、hashcode方法只有在集合中用到
3、当覆盖了equals方法时,比较对象是否相等将通过覆盖后的equals方法进行比较(判断对象的内容是否相等)。
4、将对象放入到集合中时,首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等,如果不相等直接将该对象放入集合中。如果hashcode值相等,然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等,如果equals判断不相等,直接将该元素放入到集合中,否则不放入。
5、将元素放入集合的流程图:
http://darrenzhu.iteye.com/blog/1682179
http://blog.csdn.net/e01014165/article/details/52173927
前言
为什么覆盖(不是重载)equals方法一定要覆盖hashCode方法?因为如果只覆盖了equals而没有覆盖hashCode, 则两个不同的instance(实例) a和b虽然equals结果(业务逻辑上)相等,但却会有不同的hashcode,这样hashmap里面会同时存在a和b,而实际上我们需要hashmap里面只能保存其中一个,因为从业务逻辑方向看它们是相等的.
equals方法和hashCode方法如果不同时按你自己逻辑覆盖的话,HashMap就会出问题。比如你只覆盖了equals方法而没有覆盖hashCode方法,那么HashMap在第一步寻找链表的时候会出错,有同样值的两个对象Key1和Key2并不会指向同一个链表或桶,因为你没有提供自己的hashCode方法,那么就会使用Object的hashCode方法,该方法是根据内存地址来比较两个对象是否一致,由于Key1和Key2有不桶的内存地址,所以会指向不同的链表,这样HashMap会认为key2不存在,虽然我们期望Key1和Key2是同一个对象;反之如果只覆盖了hashCode方法而没有覆盖equals方法,那么虽然第一步操作会使Key1和Key2找到同一个链表,但是由于equals没有覆盖,那么在遍历链表的元素时,key1.equals(key2)也会失败(事实上Object的equals方法也是比较内存地址),从而HashMap认为不存在Key2对象,这同样也是不正确的。
equals
· 默认情况(没有覆盖equals方法)下equals方法都是调用Object类的equals方法,而Object的equals方法主要用于判断对象的内存地址引用是不是同一个地址(是不是同一个对象)。· 要是类中覆盖了equals方法,那么就要根据具体的代码来确定equals方法的作用了,覆盖后一般都是通过对象的内容是否相等来判断对象是否相等。
1. 没有覆盖equals方法代码如下:
/学生类 public class Student { private int age; private String name; public Student() { } public Student(int age, String name) { super(); this.age = age; this.name = name; } public int getAge() { return age; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public void setName(String name) { this.name = name; } }
public class EqualsTest { public static void main(String[] args) { LinkedList<Student> list = new LinkedList<Student>(); Set<Student> set = new HashSet<Student>(); Student stu1 = new Student(3,"张三"); Student stu2 = new Student(3,"张三"); System.out.println("stu1 == stu2 : "+(stu1 == stu2)); System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); System.out.println("stu1的hashCode: "+stu1.hashCode()); System.out.println("stu2的hashCode: "+stu2.hashCode()); list.add(stu1); list.add(stu2); System.out.println("list size:"+ list.size()); set.add(stu1); set.add(stu2); System.out.println("set size:"+ set.size()); } }
运行结果:
stu1 == stu2 : false stu1.equals(stu2) : false list size:2 set size:2
结果分析:Student类没有覆盖equals方法,stu1调用equals方法实际上调用的是Object的equals方法。所以采用对象内存地址是否相等来判断对象是否相等。因为是两个新对象所以对象的内存地址不相等,所以stu1.equals(stu2) 是false。
2. 覆盖equals方法(age和name属性)后的Student类:
让Student类其通过判断对象的内容是否相等来确定对象是否相等
//学生类 public class Student { private int age; private String name; public Student() { } public Student(int age, String name) { super(); this.age = age; this.name = name; } public int getAge() { return age; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public void setName(String name) { this.name = name; } @Override public boolean equals(Object obj) { if (this == obj){ return true; } if (obj == null){ return false; } if (getClass() != obj.getClass()){ return false; } Student other = (Student) obj; if (age != other.age){ return false; } if (name == null) { if (other.name != null){ return false; } } else if (!name.equals(other.name)){ return false; } return true; } }
运行结果:
stu1 == stu2 : false stu1.equals(stu2) : true list size:2 set size:2
结果分析:
因为Student两个对象的age和name属性相等,而且又是通过覆盖equals方法来判断的,所示stu1.equals(stu2) 为true。注意以上几次测试list和set的size都是2
HashCode
hash(也被翻译为哈希、散列)算法的功能是,他能保证快速查找被检索的对象,hash算法的价值在于速度。当需要查询集合中某个元素时,hash算法可以直接根据该元素的hashCode值计算出该元素的存储位置,从而快速的定位该元素。通过上面代码的运行,我们知道equals方法已经生效。接下来我们再覆盖一下hashCode方法(通过age和name属性来生成hashcode)并不覆盖equals方法,其中Hash码是通过age和name生成的。
3. 覆盖hashCode后的Student类:
//学生类 public class Student { private int age; private String name; public Student() { } public Student(int age, String name) { super(); this.age = age; this.name = name; } public int getAge() { return age; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public void setName(String name) { this.name = name; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } }
运行结果如下:
stu1 == stu2 : false stu1.equals(stu2) : false stu1的hashCode: 775943 stu2的hashCode: 775943 list size:2 set size:2
结果分析:
我们并没有覆盖equals方法只覆盖了hashCode方法,两个对象虽然hashCode一样,但在将stu1和stu2放入set集合时由于equals方法比较的两个对象是false,所以就没有在比较两个对象的hashcode值。
4. 覆盖equals方法和hashCode方法
//学生类 public class Student { private int age; private String name; public Student() { } public Student(int age, String name) { super(); this.age = age; this.name = name; } public int getAge() { return age; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public void setName(String name) { this.name = name; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj){ return true; } if (obj == null){ return false; } if (getClass() != obj.getClass()){ return false; } Student other = (Student) obj; if (age != other.age){ return false; } if (name == null) { if (other.name != null){ return false; } } else if (!name.equals(other.name)){ return false; } return true; } }
运行结果如下:
stu1 == stu2 : false stu1.equals(stu2) : true stu1的hashCode: 775943 stu2的hashCode: 775943 list size:2 set size:1
结果分析:
stu1和stu2通过equals方法比较相等,而且返回的hashCode值一样,所以放入set集合中时只放入了一个对象。
5. 覆盖equals方法和hashCode方法,但让hashCode的值不相等
package com.why.test; //学生类 public class Student { private static int index=5; private int age; private String name; public Student() { } public Student(int age, String name) { super(); this.age = age; this.name = name; } public int getAge() { return age; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public void setName(String name) { this.name = name; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + (age+index++); result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj){ return true; } if (obj == null){ return false; } if (getClass() != obj.getClass()){ return false; } Student other = (Student) obj; if (age != other.age){ return false; } if (name == null) { if (other.name != null){ return false; } } else if (!name.equals(other.name)){ return false; } return true; } }
运行结果如下:
stu1 == stu2 : false stu1.equals(stu2) : true stu1的hashCode: 776098 stu2的hashCode: 776129 list size:2 set size:2
结果分析:
虽然stu1和stu2通过equals方法比较相等,但两个对象的hashcode的值并不相等,所以在将stu1和stu2放入set集合中时认为是两个不同的对象。
6.修改stu1的某个属性值
//学生类 public class Student { private static int index=5; private int age; private String name; public Student() { } public Student(int age, String name) { super(); this.age = age; this.name = name; } public int getAge() { return age; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public void setName(String name) { this.name = name; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj){ return true; } if (obj == null){ return false; } if (getClass() != obj.getClass()){ return false; } Student other = (Student) obj; if (age != other.age){ return false; } if (name == null) { if (other.name != null){ return false; } } else if (!name.equals(other.name)){ return false; } return true; } }
public class EqualsTest { public static void main(String[] args) { LinkedList<Student> list = new LinkedList<Student>(); Set<Student> set = new HashSet<Student>(); Student stu1 = new Student(3,"张三"); Student stu2 = new Student(3,"张三"); System.out.println("stu1 == stu2 : "+(stu1 == stu2)); System.out.println("stu1.equals(stu2) : "+stu1.equals(stu2)); list.add(stu1); list.add(stu2); System.out.println("list size:"+ list.size()); set.add(stu1); set.add(stu2); System.out.println("set size:"+ set.size()); stu1.setAge(34); System.out.println("remove stu1 : "+set.remove(stu1)); System.out.println("set size:"+ set.size()); } }
运行结果如下:
stu1 == stu2 : false stu1.equals(stu2) : true list size:2 set size:1 remove stu1 : false set size:1
结果分析:
当我们将某个对象存到set中时,如果该对象的属性参与了hashcode的计算,那么以后就不能修改该对象参与hashcode计算的那些属性了,否则会引起意向不到的错误的。正如测试中,不能够移除stu1对象
总结:
1、equals方法用于比较对象的内容是否相等(覆盖以后)2、hashcode方法只有在集合中用到
3、当覆盖了equals方法时,比较对象是否相等将通过覆盖后的equals方法进行比较(判断对象的内容是否相等)。
4、将对象放入到集合中时,首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等,如果不相等直接将该对象放入集合中。如果hashcode值相等,然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等,如果equals判断不相等,直接将该元素放入到集合中,否则不放入。
5、将元素放入集合的流程图:
相关文章推荐
- java基础-hashCode()和equals()的本质区别和联系
- Java hashCode() 和 equals()的联系与区别
- Java—hashCode与equals的区别与联系
- java基础 equals与==区别,String的hashcode
- Java 中的 ==, equals 与 hashCode 的区别与联系
- 面试题之java基础:equals()和hashCode()区别?
- Java基础 hashCode() 和equals() 区别和作用
- hashcode,==,equals的区别与联系(JAVA)
- java基础面试知识点---------java中==和equals和hashCode的区别
- Java == ,equals 和 hashcode 的区别和联系
- java的equals和hashcode方法的区别和联系
- Java学习从菜鸟变大鸟之一 hashCode()和equals()的本质区别和联系
- java基础解析系列(十一)---equals、==和hashcode方法
- Java中的“==”、equals和hashcode的区别与联系
- Java基础之hashCode()的作用,以及==、equals()和hashCode()区别
- Java hashCode与equals的区别与联系
- Java中equals()和hashCode()的区别与联系
- Java 中的 ==, equals 与 hashCode 的区别与联系
- Java基础 equals()、hashCode()和 == 区别
- Java学习从菜鸟变大鸟之一 hashCode()和equals()的本质区别和联系