关于重写equals()与hashCode()

在HashMap与HashSet中,是不允许元素重复的。

在判定时比较元素的hashCode()是否相等,equals()是否返回true,那么问题来了

这是一个Person类

public class Person {
    private String id;
    private String name;
    private Integer age;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((age == null) ? 0 : age.hashCode());
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        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;
        Person other = (Person) obj;
        if (age == null) {
            if (other.age != null)
                return false;
        } else if (!age.equals(other.age))
            return false;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    /*@Override
    public int hashCode() {
        System.out.println("id = " + id + ";id.hashCode = " + id.hashCode());
        return id.hashCode();
    }
    @Override
    public boolean equals(Object obj) {
        System.out.println("equals");
        Person p = (Person)obj;
        if(this.id == p.id) {
            return true;
        }else{
            return false;
        }
    }*/
}

这是一个Test类

public class TestHashCode {
    public static void main(String[] args) {
        Set<Person> set = new HashSet<Person>();
        Person p1 = new Person();
        p1.setId("11");
        p1.setName("张三");
        p1.setAge(20);
        Person p2 = new Person();
        p2.setId("11");
        p2.setName("李四");
        p2.setAge(30);
        set.add(p1);
        set.add(p2);
        System.out.println(p1.hashCode() == p2.hashCode());
        System.out.println(p1.equals(p2));
        for (Person person : set) {
            System.out.println(person.toString());
        }
    }
}

如果Person的id属性作为主键,且只重写equals方法,我们认为id相等的两个对象为同一个对象

此时p1.equals(p2)返回true,但是hashCode()却不相等,而hashSet判断唯一的依据是hashCode()值相等且equals()返回true

所以我们的预期是p1和p2为同一个对象,但是hashSet认为他们是两个对象。

所以我们需要同时重写hashCode()和equals()方法。

时间: 2024-10-28 08:55:26

关于重写equals()与hashCode()的相关文章

关于重写equals和hashCode

什么时候需要重写equals和hashCode方法 在比较两个对象的内容的时候,需要重写这两个方法.java系统本身提供的(==)比较方法,有两种情况: 1.比较的是基本类型数据,则此时== 跟equals的效果一致,此时比较的是2个值的大小.例如 2.比较的是对象的引用,则此时==跟equals比较的是2个引用的内存地址是否一致. 这里插入一些对象和对象的引用这个知识点, Student stu=new Student("学生A");  语句1 有人会说,stu就是Student类的

学习笔记-JAVA-考点10-什么情况下需要重写equals和hashcode()两个方法?

一.什么情况下需要重写equals和hashcode()两个方法? 1.加入到hashset中的自定义类的对象,为确保他们不重复,需要对他们的类重写equals()和hashcode()的方法. 如果不重写equals,相同内容不同引用的对象会被当做不同的对象被加入到hashset中. 重写equals()的示例代码: public boolean equals(Object obj){//这里不可以写成自定义类型自定义类型引用,这样集 <span style="white-space:p

为什么要重写equals和hashcode方法

equals hashcode 当新建一个java类时,需要重写equals和hashcode方法,大家都知道!但是,为什么要重写呢? 需要保证对象调用equals方法为true时,hashcode必须相同. 先看下面的例子: 没有重写equals和hashcode方法User类 public class User { private Integer age; private String name; public User() { } public User(Integer age, Stri

重写equals和hashCode方法的示例

如果一个类有自己特有的"逻辑相等",且需要以此进行比较时,那么就需要重写equals方法. 在Object的规范中,重写equals方法有下面几条通用约定: 自反性. x.equals(x) == true 对称性.if   y.equals(x) == true , then  x.equals(y) == true 传递性.if   x.equals(y) == true y.equals(x) == true , then x.equals(z) == true 一致性.如果比较

Java:重写equals()和hashCode()

以下内容总结自<Effective Java>. 1.何时需要重写equals() 当一个类有自己特有的“逻辑相等”概念(不同于对象身份的概念). 2.设计equals() [1]使用instanceof操作符检查“实参是否为正确的类型”. [2]对于类中的每一个“关键域”,检查实参中的域与当前对象中对应的域值. [2.1]对于非float和double类型的原语类型域,使用==比较: [2.2]对于对象引用域,递归调用equals方法: [2.3]对于float域,使用Float.float

Java 重写 equals 与 hashCode 的注意事项

为什么重写 equals 的时候必须重写 hashCode 大家可能从很多教程中了解到: SUN官方的文档中规定"如果重定义equals方法,就必须重定义hashCode方法,以便用户可以将对象插入到散列(哈希)表中" 那么 SUN 公司是出于什么考虑做了这个规定呢? 在集合框架中的HashSet,HashTable和HashMap都使用哈希表的形式存储数据,而hashCode计算出来的哈希码便是它们的身份证.哈希码的存在便可以: 快速定位对象,提高哈希表集合的性能. 只有当哈希表中对

【转】Java中==、equals、hashcode的区别与重写equals以及hashcode方法实例

原文地址:http://www.cnblogs.com/luankun0214/p/4421770.html 感谢网友的分享,记录下来只为学习. 1.重写equals方法实例   部分代码参考http://blog.csdn.net/wangloveall/article/details/7899948 重写equals方法的目的是判断两个对象的内容(内容可以有很多,比如同时比较姓名和年龄,同时相同的才是用一个对象)是否相同 如果不重写equals,那么比较的将是对象的引用是否指向同一块内存地址

重写equals和hashcode

Object的hashCode()方法,返回的是当前对象的内存地址. 以下内容总结自<Effective Java>. 1.何时需要重写equals() 当一个类有自己特有的"逻辑相等"概念(不同于对象身份的概念). 2.设计equals() [1]使用instanceof操作符检查"实参是否为正确的类型". [2]对于类中的每一个"关键域",检查实参中的域与当前对象中对应的域值. [2.1]对于非float和double类型的原语类

重写equals()和hashCode()

什么时候需要重写equals()? 只有当一个实例等于它本身的时候,equals()才会返回true值.通俗地说,此时比较的是两个引用是否指向内存中的同一个对象,也可以称做是否实例相 等.而我们在使用equals()来比较两个指向值对象的引用的时候,往往希望知道它们逻辑上是否相等,而不是它们是否指向同一个对象.在这样的情况下, 如果超类也没有重写equals()以实现期望的行为,这时我们就需要重写equals方法. 下面看一个简单示例,我们需要一系列的orderElement对象,但是当prop