危险!在HashMap中将可变对象用作Key

Posted ImportNew

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了危险!在HashMap中将可变对象用作Key相关的知识,希望对你有一定的参考价值。


来源:ImportNew - 刁文阳,


本文中我们将会讨论在Java HashMap中将可变对象用作Key。所有的Java程序员可能都在自己的编程经历中多次用过HashMap。那什么是HashMap呢?


HashMap是一种用哈希值来存储和查找键值对(key-value pair,也称作entry)的一种数据结构。


为了正确使用HashMap,选择恰当的Key是非常重要的。Key在HashMap里是不可重复的。


1、什么是可变对象


可变对象是指创建后自身状态能改变的对象。换句话说,可变对象是该对象在创建后它的哈希值可能被改变。


在下面的代码中,对象MutableKey的键在创建时变量 i=10 j=20,哈希值是1291。


然后我们改变实例的变量值,该对象的键 i 和 j 从10和20分别改变成30和40。现在Key的哈希值已经变成1931。


显然,这个对象的键在创建后发生了改变。所以类MutableKey是可变的。


让我们看看下面的示例代码:


注意:调用hashCode()时,equals()方法也同时被执行。


public class MutableKey {

    private int i;

    private int j;

 

    public MutableKey(int i, int j) {

        this.i = i;

        this.j = j;

    }

 

    public final int getI() {

        return i;

    }

 

    public final void setI(int i) {

        this.i = i;

    }

 

    public final int getJ() {

        return j;

    }

 

    public final void setJ(int j) {

        this.j = j;

    }

 

    @Override

    public int hashCode() {

        final int prime = 31;

        int result = 1;

        result = prime * result + i;

        result = prime * result + j;

        return result;

    }

 

    @Override

    public boolean equals(Object obj) {

        if (this == obj) {

            return true;

        }

        if (obj == null) {

            return false;

        }

        if (!(obj instanceof MutableKey)) {

            return false;

        }

        MutableKey other = (MutableKey) obj;

        if (i != other.i) {

            return false;

        }

        if (j != other.j) {

            return false;

        }

        return true;

    }

}


public class MutableDemo {

 

    public static void main(String[] args) {

 

        // Object created

        MutableKey key = new MutableKey(10, 20);

        System.out.println("Hash code: " + key.hashCode());

 

        // Object State is changed after object creation.

        key.setI(30);

        key.setJ(40);

        System.out.println("Hash code: " + key.hashCode());

    }

}


输出:


Hash code: 1291

Hash code: 1931


2、HashMap如何存储键值对


HashMap用Key的哈希值来存储和查找键值对。


当插入一个Entry时,HashMap会计算Entry Key的哈希值。Map会根据这个哈希值把Entry插入到相应的位置。


查找时,HashMap通过计算Key的哈希值到特定位置查找这个Entry。


3、在HashMap中使用可变对象作为Key带来的问题


如果HashMap Key的哈希值在存储键值对后发生改变,Map可能再也查找不到这个Entry了。


如果Key对象是可变的,那么Key的哈希值就可能改变。在HashMap中可变对象作为Key会造成数据丢失。


下面的例子将会向你展示HashMap中有可变对象作为Key带来的问题。


import java.util.HashMap;

import java.util.Map;

 

public class MutableDemo1 {

 

    public static void main(String[] args) {

 

        // HashMap

        Map<MutableKey, String> map = new HashMap<>();

 

        // Object created

        MutableKey key = new MutableKey(10, 20);

 

        // Insert entry.

        map.put(key, "Robin");

 

        // This line will print 'Robin'

        System.out.println(map.get(key));

 

        // Object State is changed after object creation.

        // i.e. Object hash code will be changed.

        key.setI(30);

 

        // This line will print null as Map would be unable to retrieve the

        // entry.

        System.out.println(map.get(key));

    }

}


输出:


Robin

null


4、如何解决


在HashMap中使用不可变对象。在HashMap中,使用String、Integer等不可变类型用作Key是非常明智的。


我们也能定义属于自己的不可变类。


如果可变对象在HashMap中被用作键,那就要小心在改变对象状态的时候,不要改变它的哈希值了。


在下面的Employee示例类中,哈希值是用实例变量id来计算的。一旦Employee的对象被创建,id的值就能再改变。只有name可以改变,但name不能用来计算哈希值。所以,一旦Employee对象被创建,它的哈希值不会改变。所以Employee在HashMap中用作Key是安全的。


示例代码:


import java.util.HashMap;

import java.util.Map;

 

public class MutableSafeKeyDemo {

 

    public static void main(String[] args) {

        Employee emp = new Employee(2);

        emp.setName("Robin");

 

        // Put object in HashMap.

        Map<Employee, String> map = new HashMap<>();

        map.put(emp, "Showbasky");

 

        System.out.println(map.get(emp));

 

        // Change Employee name. Change in 'name' has no effect

        // on hash code.

        emp.setName("Lily");

        System.out.println(map.get(emp));

    }

}

 

class Employee {

    // It is specified while object creation.

    // Cannot be changed once object is created. No setter for this field.

    private int id;

    private String name;

 

    public Employee(final int id) {

        this.id = id;

    }

 

    public final String getName() {

        return name;

    }

 

    public final void setName(final String name) {

        this.name = name;

    }

 

    public int getId() {

        return id;

    }

 

    // Hash code depends only on 'id' which cannot be

    // changed once object is created. So hash code will not change

    // on object's state change

    @Override

    public int hashCode() {

        final int prime = 31;

        int result = 1;

        result = prime * result + id;

        return result;

    }

 

    @Override

    public boolean equals(Object obj) {

        if (this == obj)

            return true;

        if (obj == null)

            return false;

        if (getClass() != obj.getClass())

            return false;

        Employee other = (Employee) obj;

        if (id != other.id)

            return false;

        return true;

    }

}


输出:


Showbasky

Showbasky


现在你可能已经理解在HashMap中用可变对象作为Key的危险了。关于本文欢迎提出的任何建议和意见。


看完本文有收获?请转发分享给更多人

关注「ImportNew」,提升Java技能

以上是关于危险!在HashMap中将可变对象用作Key的主要内容,如果未能解决你的问题,请参考以下文章

C# Dictionary<> 和可变键

Java Map中key用可变对象会是什么后果?

HashMap

java中String为什么设计成不可变对象

.NET Dictionary 实现如何与可变对象一起使用

待确定的数据:内部可变性还是单独的HashMap?