允许Key重复的Map - IdentityHashMap

2011-11-06 22:28:35





  文章转自http://tianya23.blog.51cto.com/1081650/707603

在使用map的时候，大家肯定会想到key-value，key用于检索value的内容。在正常情况下，可以不允许重复；但是其实重复在java中分为2中情况，一是内存地址重复，另一个是不同的地址但内容相等，而IdentityHashMap用于后者，即内容相等。    更详细的解释如下：此类利用哈希表实现 Map 接口，比较键（和值）时使用引用相等性代替对象相等性。换句话说，在 IdentityHashMap 中，当且仅当 (k1==k2) 时，才认为两个键 k1 和 k2 相等（在正常 Map 实现（如 HashMap）中，当且仅当满足下列条件时才认为两个键 k1 和 k2 相等：(k1==null
 ? k2==null : e1.equals(e2))）。

ps：IdentityHashMap中相当于使用用object.equals()进行判断，直接用地址判断对象相等。如果自己实现的类做键值，而其中的equals等价于object.equals()的方法，则此时的HashMap类似于IdentityHashMap。

此类不是 通用 Map 实现！此类实现 Map 接口时，它有意违反 Map 的常规协定，该协定在比较对象时强制使用 equals 方法。此类设计仅用于其中需要引用相等性语义的罕见情况。

 

 例如：
class Person{ 
    private String name ; 
    private int age ; 
    public Person(String name,int age){ 
        this.name = name ; 
        this.age = age ; 
    } 
    public boolean equals(Object obj){ 
        if(this==obj){ 
            return true ; 
        } 
        if(!(obj instanceof Person)){ 
            return false ; 
        } 
        Person p = (Person)obj ; 
        if(this.name.equals(p.name)&&this.age==p.age){ 
            return true ; 
        }else{ 
            return false ; 
        } 
    } 
    public int hashCode(){ 
        return this.name.hashCode() * this.age ; 
    } 
    public String toString(){ 
        return "姓名：" + this.name + "，年龄：" + this.age ; 
    } 
}; 

HashMap情况：
public class IdentityHashMapDemo01{ 
    public static void main(String args[]){ 
        Map<Person,String> map = null ; // 声明Map对象 
        map = new HashMap<Person,String>() ; 
        map.put(new Person("张三",30),"zhangsan_1") ; // 加入内容 
        map.put(new Person("张三",30),"zhangsan_2") ; // 加入内容 
        map.put(new Person("李四",31),"lisi") ;   // 加入内容 
        Set<Map.Entry<Person,String>> allSet = null ;   // 准备使用Set接收全部内容 
        allSet = map.entrySet() ; 
        Iterator<Map.Entry<Person,String>> iter = null ; 
        iter = allSet.iterator() ; 
        while(iter.hasNext()){ 
            Map.Entry<Person,String> me = iter.next() ; 
            System.out.println(me.getKey() + " --> " + me.getValue()) ; 
        } 
    } 
}; 

结果：相同的key内容，value会被覆盖
姓名：李四，年龄：31 --> lisi 
姓名：张三，年龄：30 --> zhangsan_2 

IdentityHashMap情况
public class IdentityHashMapDemo02{ 
    public static void main(String args[]){ 
        Map<Person,String> map = null ; // 声明Map对象 
        map = new IdentityHashMap<Person,String>() ; 
        map.put(new Person("张三",30),"zhangsan_1") ; // 加入内容 
        map.put(new Person("张三",30),"zhangsan_2") ; // 加入内容 
        map.put(new Person("李四",31),"lisi") ;   // 加入内容 
        Set<Map.Entry<Person,String>> allSet = null ;   // 准备使用Set接收全部内容 
        allSet = map.entrySet() ; 
        Iterator<Map.Entry<Person,String>> iter = null ; 
        iter = allSet.iterator() ; 
        while(iter.hasNext()){ 
            Map.Entry<Person,String> me = iter.next() ; 
            System.out.println(me.getKey() + " --> " + me.getValue()) ; 
        } 
    } 
}; 

结果：相同的key内容(由于是new出来的，内存地址不同但内容相同)，但value不会被覆盖
姓名：张三，年龄：30 --> zhangsan_2 
姓名：张三，年龄：30 --> zhangsan_1 
姓名：李四，年龄：31 --> lisi 

在Java中，有一种key值可以重复的map，就是IdentityHashMap。在IdentityHashMap中，判断两个键值k1和 k2相等的条件是 k1 == k2 。在正常的Map 实现(如 HashMap)中，当且仅当满足下列条件时才认为两个键 k1 和 k2 相等：(k1==null ? k2==null : e1.equals(e2))。
IdentityHashMap类利用哈希表实现 Map 接口，比较键(和值)时使用引用相等性代替对象相等性。该类不是 通用 Map 实现！此类实现 Map 接口时，它有意违反 Map 的常规协定，该协定在比较对象时强制使用 equals 方法。此类设计仅用于其中需要引用相等性语义的罕见情况。
在使用IdentityHashMap有些需要注意的地方:
例子1：
IdentityHashMap map =new IdentityHashMap();
map.put(newString("xx"),"first");
map.put(newString("xx"),"second");
for (Entry entry : map.entrySet()) {
System.out.print(entry.getKey() +"    ");
System.out.println(entry.getValue());
}
System.out.println("idenMap="+map.containsKey("xx"));
System.out.println("idenMap="+map.get("xx"));
输出结果是：
xx    first
xx    second
idenMap=false
idenMap=null
例子2：
IdentityHashMap map =new IdentityHashMap();
String fsString =newString("xx");
map.put(fsString,"first");
map.put(newString("xx"),"second");
for(Entry entry : map.entrySet()) {
System.out.print(entry.getKey() +"    ");
System.out.println(entry.getValue());
}
System.out.println("idenMap="+map.containsKey(fsString));
System.out.println("idenMap="+map.get(fsString));
输出结果是：
xx    second
xx    first
idenMap=true
idenMap=first
例子3：
IdentityHashMap map =new IdentityHashMap();
String fsString =newString("xx");
map.put(fsString,"first");
map.put(fsString,"second");
for(Entry entry : map.entrySet()) {
System.out.print(entry.getKey() +"    ");
System.out.println(entry.getValue());
}
System.out.println("idenMap="+map.containsKey(fsString));
System.out.println("idenMap="+map.get(fsString));
输出结果是：
xx    second
idenMap=true
idenMap=second
例子4：
IdentityHashMap map =new IdentityHashMap();
String fsString =newString("xx");
String secString =newString("xx");
map.put(fsString,"first");
map.put(secString,"second");
for(Entry entry : map.entrySet()) {
System.out.print(entry.getKey() +"    ");
System.out.println(entry.getValue());
}
System.out.println("idenMap="+map.containsKey(fsString));
System.out.println("idenMap="+map.get(fsString));
System.out.println("idenMap="+map.containsKey(secString));
System.out.println("idenMap="+map.get(secString));
输出结果是：
xx    first
xx    second
idenMap=true
idenMap=first
idenMap=true
idenMap=second
例子5：
IdentityHashMap map =new IdentityHashMap();
map.put("xx","first");
map.put("xx","second");
for(Entry entry : map.entrySet()) {
System.out.print(entry.getKey() +"    ");
System.out.println(entry.getValue());
}
输出结果是：
xx    second
可以看到，在IdentityHashMap中，是判断key是否为同一个对象，而不是普通HashMap的equals方式判断。
参考：http://blog.csdn.net/stoneok07/article/details/7262676

我们平时使用的Map，都是只能在Map中保存一个相同的Key，我们后面保存的相同的key都会将原来的key的值覆盖掉，如下面的例子。
public class test {
public
static void main(String[] args) {
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1 == str2); //false
Map map = new HashMap();
map.put(str1, "hello");
map.put(str2, "world");
for(Entry entry :map.entrySet())
{
System.out.println(entry.getKey()+" " + entry.getValue());
}
System.out.println("---->" + map.get("abc"));
}
}
这个例子中我们可以看见相同的key只能保存一个value值，下面我们来看一种map可以实现一个key中保存多个value。这个map也就是IdentityHashMap。下面我们就来介绍下IdentityHashMap这个类的使用。
API上这样来解释这个类的：此类不是通用Map实现！此类实现Map接口时，它有意违反Map的常规协定，该协定在比较对象时强制使用
equals 方法。此类设计仅用于其中需要引用相等性语义的罕见情况。
IdentityHashMap类利用哈希表实现Map接口，比较键(和值)时使用引用相等性代替对象相等性。我们来看看这个类的代码吧：
public class test1 {
public
static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2); //true
Map map = new IdentityHashMap();
map.put(str1, "hello");
map.put(str2, "world");
for(Entry entry : map.entrySet())
{
System.out.println(entry.getKey()+" " + entry.getValue());
}
System.out.println("containsKey---> " +
map.containsKey("abc"));
System.out.println("value----> " + map.get("abc"));
}
}
这端代码输出的结果如下：
true
abc world
containsKey---> true
value----> world
为什么我们的Key还是只保存了一个值？？？？这个问题和《java解惑第62题一样》书上面是这样解释的，我们来看看：
语言规范保证了字符串是内存限定的，换句话说，相等的字符串常量同时也是相同的对象。这可以确保在我们的程序中第二次出现的字符串字面常量“abc”引用到了与第一次相同的String实例上，因此尽管我们使用了一个IdentityHashMap来代替诸如HashMap这样的通用目的的Map实现，但是对程序的行为却不会产生任何影响。
我们来看看下面的代码就可以实现一个key保存两个value的情况。我们的代码如下:
public class test1 {
public
static void main(String[] args) {
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1 == str2); //false
Map map = new IdentityHashMap();
map.put(str1, "hello");
map.put(str2, "world");
for(Entry entry : map.entrySet())
{
System.out.println(entry.getKey()+" " + entry.getValue());
}
System.out.println(" containsKey---> " + map.containsKey("abc"));
System.out.println("str1 containsKey---> " +
map.containsKey(str1));
System.out.println("str2 containsKey---> " +
map.containsKey(str2));
System.out.println(" value----> " + map.get("abc"));
System.out.println("str1 value----> " +
map.get(str1));
System.out.println("str2 value----> " +
map.get(str2));
}
}
我们的看看输出的结果为：
false
abc world
abc hello
containsKey---> false
str1 containsKey---> true
str2 containsKey---> true
value----> null
str1 value----> hello
str2 value----> world
我们可以知道IdentityHashMap是靠对象来判断key是否相等的，如果我们一个key需要保存多个value的时候就需要使用到这个IdentityHashMap类，这样我们我们就可以需要的时候使用到这个类了。

关于map集合,key值相同时,value值会被覆盖,查阅API相关的说明.
如果原来的key已经存在，则直接将新值覆盖到原值上面.
那么问题来了,有时候后台需要我们发送json字符串数组,这时候就需要map集合的key值时相同的,网上找了很多方法,
都是说重写key的hashCode()和map的put()方法,就可以实现对于相同key下多个value的存储.
而我推荐的方法是使用IdentityHashMap.
IdentityHashMap和HashMap之间的区别,根据网友的回复:
穿同样颜色衣服的双胞胎(HashMap)
穿不同颜色双胞胎弟弟(IdentityHashMap)
区别与其他的键不能重复的容器，IdentityHashMap允许key值重复，但是——key必须是两个不同的对象，即对于k1和k2，当k1==k2时，IdentityHashMap认为两个key相等，而HashMap只有在k1.equals(k2) == true 时才会认为两个key相等。
因此:IdentityHashMap maps = new IdentityHashMap<>();
maps.put("key",value1);
maps.put("key",
value2);
maps.put("key",
value3);
map.size = 3;
特此记录.