java-map-IdentityHashMap

1、背景　

　今天翻开IdentityHashMap的时候，就傻眼了，这个到底是个逻辑啊，我的程序代码如下：

  IdentityHashMap<String,String> identityHashMap=new IdentityHashMap<String, String>();

     private void initMap(){
         identityHashMap.put("zhangsan","age:18");
         identityHashMap.put("lisi","age:24");
     }

     public String getAge(String name){
         return identityHashMap.get(name);
     }

     public static void main(String[] args) {
         IdentityHashMapTest test=new IdentityHashMapTest();
         test.initMap();

         String zhangsan=new String("zhangsan");
         String lisi=new String("lisi");
         System.out.println("zhangsan age is ="+ test.getAge(zhangsan));
         System.out.println("lisi age is ="+ test.getAge(lisi));

     }

运行的结果如下：

zhangsan age is =null
lisi age is =null

为什么如此呢？

2、源码探索

This class implements the <tt>Map</tt> interface with a hash table, using
* reference-equality in place of object-equality when comparing keys (and
* values).  In other words, in an <tt>IdentityHashMap</tt>, two keys
* <tt>k1</tt> and <tt>k2</tt> are considered equal if and only if
* <tt>(k1==k2)</tt>.  (In normal <tt>Map</tt> implementations (like
* <tt>HashMap</tt>) two keys <tt>k1</tt> and <tt>k2</tt> are considered equal
* if and only if <tt>(k1==null ? k2==null : k1.equals(k2))</tt>.)
也就是说IdentityHashMap的用法是，如果两个key是引用相等的时候，才会返回存在map里面的数据，否则返回为null，并不是像HashMap中的只是比较key的值是否相等

(k = p.key) == key || (key != null && key.equals(k))

put方法：

 public V put(K key, V value) {
         Object k = maskNull(key);
         Object[] tab = table;
         int len = tab.length;
         int i = hash(k, len);

         Object item;
         while ( (item = tab[i]) != null) {
             if (item == k) {
                 V oldValue = (V) tab[i + 1];
                 tab[i + 1] = value;
                 return oldValue;
             }
             i = nextKeyIndex(i, len);
         }

         modCount++;
         tab[i] = k;
         tab[i + 1] = value;
         if (++size >= threshold)
             resize(len); // len == 2 * current capacity.
         return null;
     }

　　从这里可以看出,int i = hash(k, len);一定是一个偶数值，并且这里使用的while循环操作，可能会有性能问题。

　　这里key是放在偶数的位置，而value是存放在key对应的下个一个位置中　　

　　当size>threshold的时候，就会去扩容。

get方法

 public V get(Object key) {
         Object k = maskNull(key);
         Object[] tab = table;
         int len = tab.length;
         int i = hash(k, len);
         while (true) {
             Object item = tab[i];
             if (item == k)
                 return (V) tab[i + 1];
             if (item == null)
                 return null;
             i = nextKeyIndex(i, len);
         }
     }

　　这里查找value的时候也是使用while循环查找，不断的去轮询找key，知道遇到空。

　　也是使用强引用的比较，如果是key1==key2,才会返回对应的值。

3、使用场景

　　现在想想这中map的设计，也挺有意思的。

　　比如我想在户口登记处中找到一个叫张三的，他现在几岁了？全国叫张三的人这么多，户口注册的时候，又没有说不能重名，我怎么知道这个张三是否是你要找的那个张三呢？所以这个时候就可以使用IdentityHashMap来存储了，只有是保证强引用的时候，才可以找到，否则，我还是会告诉你，我不知道张三是谁