本文中我们将会讨论在Java HashMap中将可变对象用作Key。所有的Java程序员可能都在自己的编程经历中多次用过HashMap。那什么是HashMap呢?
HashMap是一种用哈希值来存储和查找键值对(key-value pair,也称作entry)的一种数据结构。
为了正确使用HashMap,选择恰当的Key是非常重要的。Key在HashMap里是不可重复的。
内容
- 什么是可变对象
- HashMap如何存储键值对
- 在HashMap中使用可变对象作为Key带来的问题
- 如何解决
1、什么是可变对象
可变对象是指创建后自身状态能改变的对象。换句话说,可变对象是该对象在创建后它的哈希值可能被改变。
在下面的代码中,对象MutableKey的键在创建时变量 i=10 j=20,哈希值是1291。
然后我们改变实例的变量值,该对象的键 i 和 j 从10和20分别改变成30和40。现在Key的哈希值已经变成1931。
显然,这个对象的键在创建后发生了改变。所以类MutableKey是可变的。
让我们看看下面的示例代码:
注意:调用hashCode()时,equals()方法也同时被执行。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 | 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 ;
}
}
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | 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());
}
}
|
输出:
1 2 | 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带来的问题。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | 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));
}
}
|
输出:
4、如何解决
在HashMap中使用不可变对象。在HashMap中,使用String、Integer等不可变类型用作Key是非常明智的。
我们也能定义属于自己的不可变类。
如果可变对象在HashMap中被用作键,那就要小心在改变对象状态的时候,不要改变它的哈希值了。
在下面的Employee示例类中,哈希值是用实例变量id来计算的。一旦Employee的对象被创建,id的值就能再改变。只有name可以改变,但name不能用来计算哈希值。所以,一旦Employee对象被创建,它的哈希值不会改变。所以Employee在HashMap中用作Key是安全的。
示例代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | 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 ;
}
}
|
输出:
现在你可能已经理解在HashMap中用可变对象作为Key的危险了。关于本文欢迎提出的任何建议和意见。
原文链接: java-fries 翻译: ImportNew.com - 刁 文阳 译文链接: http://www./13384.html [ 转载请保留原文出处、译者和译文链接。]
|