深入理解HashMap

简要介绍

• HashMap是基于哈希表实现的，每一个元素都是一个key-value对，其内部通过单链表解决冲突问题，容量不足（超过了阈值）时，同样会自动增长。
• HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
• HashMap 继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。
• HashMap的实现不是同步的，这意味着它不是线程安全的。它的key、value都可以为null。此外，HashMap中的映射不是有序的。
• HashMap 的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
• 通常，默认加载因子是0.75,这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数HashMap类的操作中，包括get和put操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。

重要源码

//get操作
// 获取key对应的value    
public V get(Object key) {    
    if (key == null)    
        return getForNullKey();    
    // 获取key的hash值    
    int hash = hash(key.hashCode());    
    // 在“该hash值对应的链表”上查找“键值等于key”的元素    
    for (Entry<K,V> e = table[indexFor(hash, table.length)];    
         e != null;    
         e = e.next) {    
        Object k;    
/判断key是否相同  
        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))    
            return e.value;    
    }  
没找到则返回null  
    return null;    
}    

// 获取“key为null”的元素的值    
// HashMap将“key为null”的元素存储在table[0]位置，但不一定是该链表的第一个位置！    
private V getForNullKey() {    
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {    
        if (e.key == null)    
            return e.value;    
    }    
    return null;    
}    

//put操作
// 将“key-value”添加到HashMap中    
  public V put(K key, V value) {    
      // 若“key为null”，则将该键值对添加到table[0]中。    
      if (key == null)    
          return putForNullKey(value);    
      // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。    
      int hash = hash(key.hashCode());    
      int i = indexFor(hash, table.length);    
      for (Entry<K,V> e = table[i]; e != null; e = e.next) {    
          Object k;    
          // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！    
          if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {    
              V oldValue = e.value;    
              e.value = value;    
              e.recordAccess(this);    
              return oldValue;    
          }    
      }    

      // 若“该key”对应的键值对不存在，则将“key-value”添加到table中    
      modCount++;  
//将key-value添加到table[i]处  
      addEntry(hash, key, value, i);    
      return null;    
  }   

// putForNullKey()的作用是将“key为null”键值对添加到table[0]位置    
private V putForNullKey(V value) {    
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {    
        if (e.key == null) {    
            V oldValue = e.value;    
            e.value = value;    
            e.recordAccess(this);    
            return oldValue;    
        }    
    }    
    // 如果没有存在key为null的键值对，则直接题阿见到table[0]处!    
    modCount++;    
    addEntry(0, null, value, 0);    
    return null;    
}   

使用

    public static void main(String[] args) {
        HashMap<String, String> strMap = new HashMap<String,String>();
        strMap.put("1", "one");
        strMap.put("2", "two");
        strMap.put("3", "three");
        strMap.put("5", "five");
        strMap.put("6", "six");
        System.out.println("strMap:"+strMap);

        System.out.println("strMap.get(1):"+strMap.get("1"));
        System.out.println("strMap.containsKey(2):"+strMap.containsKey("2"));
        System.out.println("strMap.remove(3):"+strMap.remove("3"));
        System.out.println("strMap:"+strMap);

        System.out.println("strMap.size():"+strMap.size());
        System.out.println("strMap.isEmpty():"+strMap.isEmpty());
        System.out.println("strMap.keySet():"+strMap.keySet());
        System.out.println("strMap.entrySet():"+strMap.entrySet());
        System.out.println("strMap.values():"+strMap.values());

        System.out.println("keySet迭代器遍历");
        Iterator<String> strItr = strMap.keySet().iterator();
        while(strItr.hasNext()){
            System.out.println(strItr.next());
        }

        System.out.println("entrySet迭代器遍历");
        Iterator<Entry<String, String>> entryIter = strMap.entrySet().iterator();
        while(entryIter.hasNext()){
            System.out.println(entryIter.next());
        }
    }
/**********************结果打印如下：*************************
strMap:{1=one, 2=two, 3=three, 5=five, 6=six}
strMap.get(1):one
strMap.containsKey(2):true
strMap.remove(3):three
strMap:{1=one, 2=two, 5=five, 6=six}
strMap.size():4
strMap.isEmpty():false
strMap.keySet():[1, 2, 5, 6]
strMap.entrySet():[1=one, 2=two, 5=five, 6=six]
strMap.values():[one, two, five, six]
keySet迭代器遍历
1
2
5
6
entrySet迭代器遍历
1=one
2=two
5=five
6=six
**********************************************************/

重点总结

1.get方法
首先，如果key为null，则直接从哈希表的第一个位置table[0]对应的链表上查找。记住，key为null的键值对永远都放在以table[0]为头结点的链表中，当然不一定是存放在头结点table[0]中。如果key不为null，则先求的key的hash值，根据hash值找到在table中的索引，在该索引对应的单链表中查找是否有键值对的key与目标key相等，有就返回对应的value，没有则返回null。

2.put方法
如果key为null，则将其添加到table[0]对应的链表中。如果key不为null，则同样先求出key的hash值，根据hash值得出在table中的索引，而后遍历对应的单链表，如果单链表中存在与目标key相等的键值对，则将新的value覆盖旧的value，比将旧的value返回，如果找不到与目标key相等的键值对，或者该单链表为空，则将该键值对插入到改单链表的头结点位置（每次新插入的节点都是放在头结点的位置）。
每次加入键值对时，都要判断当前已用的槽的数目是否大于等于阀值（容量*加载因子），如果大于等于，则进行扩容，将容量扩为原来容量的2倍。扩容是一个相当耗时的操作，因为它需要重新计算这些元素在新的数组中的位置并进行复制处理。因此，我们在用HashMap的时，最好能提前预估下HashMap中元素的个数，这样有助于提高HashMap的性能。

3.HashMap中key和value都允许为null。

4.注意containsKey方法和containsValue方法。前者直接可以通过key的哈希值将搜索范围定位到指定索引对应的链表，而后者要对哈希