Java Hash集合的equals()与hashCode() 方法

　　Java 集合实现类，无论是HashSet、HashMap等所有的Hash算法实现的集合类（后面简称Hash集合），加入的对象必须实现 hashCode() 与 equals() 方法，稍微不同的地方是：HashSet 需要对整个对象实现两个方法，而HashMap 只需要对作为key的对象实现这两个方法。因为向Hash集合存入一个元素时，Hash集合会调用该对象的hashCode()方法来得到该对象的hashCode的值，然后根据hashCode的值决定该对象在Hash集合中存储位置。如果两个元素通过equals()方法比较返回true，但它们的hashCode()方法返回值不相等，Hash集合将会把它们视为不同的对象，两个元素都可以添加到Hash集合里。所以Hash集合判断两个元素是否相等的标准是：两个对象通过equals()方法比较相等，并且两个元素的hashCode()方法返回值也相等。

 

重写hashCode()方法的规则：

① 同一个对象多次调用hashCode()方法返回值相同

② 两个对象通过equals()方法比较返回true 时，这两个对象的hashCode()方法返回相等的值

③ 对象中用于equals() 方法比较标准的变量，都应该用于计算hashCode值

 

重写hashCode方法一般步骤

① 把对象内每个有意义的变量计算出一个int 型的hashCode值

② 用第1步计算出来的多个hashCode值组合成一个hashCode值返回

③ 为了避免直接相加产生偶然相等，可以通过为各变量的hashCode值乘以任意质数再相加

 

案例：

① 首先来看一个没有重写equals() 与 hashCode() 方法的对象，添加到HashSet 时会出现什么情况。

我们创建一个Person类，包含两个成员变量，id 与 name，如果两个对象的这两个属性都不等我们才认为它们是不同的对象，我们没有重写equals() 与 hashCode() 方法，但是我们希望HashSet 集合对同一个对象只能保存一份，有相同对象加入时，加入失败。

class Person
{
    private String name;
    private int id; 
    
    public Person()
    {}
    
    public Person(int id,String name)
    {
        this.id = id;
        this.name = name;
    }
    
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

        
        HashSet haSe = new HashSet();
        
        //相同id与name的添加两次
        haSe.add(new Person(1001, "latiny"));
        haSe.add(new Person(1001, "latiny"));
        
        //遍历HashSet
        for(Object obj:haSe)
        {
            Person p = (Person)obj;
            System.out.println(p.getId()+" "+p.getName()+" "+p.hashCode());
        }
        

　　输出结果：

1001 latiny 355165777
1001 latiny 1807500377

可以看到name与id相同的两个对象都成功的加入到了HashSet集合，因为它们的hashCode值不一样，这显然没有达到预期的效果，如果要实现预期的效果需要重写Person类 equals() 与 hashCode() 方法。

 

② 重写Person类equals() 与 hashCode() 方法

在上面的Person类添加如下代码：

    //重写hashCode() 方法
    public int hashCode() {
        int hash = 7;
        hash = hash*31 + this.id*11 + this.name.hashCode()*31;
        return hash;
    }

    //重写equals() 方法
    public boolean equals(Object obj) {
        if(this==obj)
        {
            return true;
        }
        //如果两个对象的id与name都相等，则两个对象相等
        if(obj.getClass()==Person.class)
        {
            Person p=(Person)obj;
            return this.id==p.id && this.name==p.name;
        }
        else
        {
            return false;
        }
    }

　　

　　重新执行代码：

        
        HashSet haSe = new HashSet();
        
        //相同id与name的对象添加两次
        haSe.add(new Person(1001, "latiny"));
        System.out.println(haSe.add(new Person(1001, "latiny")));
        
        //遍历HashSet
        for(Object obj:haSe)
        {
            Person p = (Person)obj;
            System.out.println(p.getId()+" "+p.getName()+" "+p.hashCode());
        }
        

　　输出结果：　

false
1001 latiny -46445433

可以看到 id与 name 相同的两个对象只有一个加入到了HashSet集合，第二次添加时失败，因为我们重写了equals() 与 hashCode() 方法，只要Person类对象id与name都相同，equals()返回true，hashCode() 返回值相同，HashSet集合就会将这两个对象视为同一个对象。

 

HashMap 的使用与HashSet类似，作为key的对象也需要重写 equals() 与 hashCode() 方法，不然也会出现将相同对象作为key值成功插入到HashMap中。

① 未重写 equals() 与 hashCode() 方法

class Person
{
    private String name;
    private int id; 
    
    public Person()
    {}
    
    public Person(int id,String name)
    {
        this.id = id;
        this.name = name;
    }
    
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

　　

　　将Person类作为HashMap的key

        
        HashMap<Person, String> hash = new HashMap<Person, String>();
        hash.put(new Person(1, "latiny"), "周瑜");
        hash.put(new Person(1, "latiny"), "曹操");
        hash.put(new Person(1, "latiny"), "刘禅");
        
        //foreach遍历HashMap
        for(Object key:hash.keySet())
        {
            String name = hash.get(key);
            System.out.println(key+"-->"+name+" "+key.hashCode());
        }
        
        Object obj = hash.get(new Person(1, "latiny"));
        String name = (String) obj;
        System.out.println(name);

　　输出结果：

com.latiny.set.Person@544a5ab2-->刘禅 1414159026
com.latiny.set.Person@152b6651-->曹操 355165777
com.latiny.set.Person@6bbc4459-->周瑜 1807500377
null

可以看到，id 与 name 相同的Person对象作为 key 重复添加到HashMap集合中。

更为严重的问题是，当我们想要以相同的 id 与 name的Person对象作为key去获取value 时，结果竟然是null，为什么呢？因为这个Person对象的id 与 name 与之前的三个对象相同，但是在内存中它却是一个新的对象，有自己独立的空间，即有自己独立的hashCode值，由于我们没有重写hashCode方法，它的hashCode计算方法还是按照Object这个类来实现的。

 

② 重写 equals() 与 hashCode() 方法之后

class Person
{
    private String name;
    private int id; 
    
    public Person()
    {}
    
    public Person(int id,String name)
    {
        this.id = id;
        this.name = name;
    }
    
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    
    //重写hashCode() 方法
    public int hashCode() {
        int hash = 7;
        hash = hash*31 + this.id*11 + this.name.hashCode()*31;
        return hash;
    }

    //重写equals() 方法
    public boolean equals(Object obj) {
        if(this==obj)
        {
            return true;
        }
        //如果两个对象的id与name都相等，则两个对象相等
        if(obj.getClass()==Person.class)
        {
            Person p=(Person)obj;
            return this.id==p.id && this.name==p.name;
        }
        else
        {
            return false;
        }
    }
    
}

　　执行测试代码

        
        HashMap<Person, String> hash = new HashMap<Person, String>();
        hash.put(new Person(1, "latiny"), "周瑜");
        hash.put(new Person(1, "latiny"), "曹操");
        hash.put(new Person(1, "latiny"), "刘禅");
        
        //foreach遍历HashMap
        for(Object key:hash.keySet())
        {
            String name = hash.get(key);
            System.out.println(key+"-->"+name+" "+key.hashCode());
        }
        
        Object obj = hash.get(new Person(1, "latiny"));
        String name = (String) obj;
        System.out.println(name);
        

　　输出结果：

com.latiny.set.Person@fd3b218f-->刘禅 -46456433
刘禅

可以看到，最后一次添加的元素将之前添加的都覆盖了，因为我们重写的方法判断如果Person类的id与name相同，equals()返回true， hashCode() 返回相同的值，HashMap认定它们key值相同，会将之前加入的元素覆盖。我们也可以将具有相同的id与name的Person类作为key值去访问value。