Java集合系列（6）--HashMap

刷题到一半，竟然开始怀疑自己的智商了，放下来，还是先看点基础，路还长，哈哈。。。

前面，我们已对List进行了学习，接下来，我们先学习Map，然后再学习Set；因为Set的实现类都是基于Map实现的（如HashSet是通过HashMap实现的，TreeSet是通过TreeMap实现的）

一、HashMap的基本概述

HashMap是一个散列表（链表+数组），它存储的内容是键值对（Key-Value）映射
HashMap继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。
HashMap的实现是非同步的，意味着它不是线程安全的。它的Key、Value值都可以为空，并且HashMap中的映射不是有序的。

面试易考点：

关注点 结论 结合底层实现的数据结构 散列表（数组+列表） 集合中元素是否允许为空 Key和value都可以为空 是否允许数据重复 key值会被覆盖，value允许重复 是否有序 无序，是指不是按put添加的顺序 是否线程安全 非线程安全（不是同步的）

二、HashMap的数据结构

1> HashMap的实例有两个参数影响其性能：“初始容量”和“加载因子”。“容量”是哈希表中桶的数量，“初始容量”只是哈希表在创建时的容量。“加载因子”是哈希表在其容量自增所达到的一种尺度。当哈希表中的内容超过了加载因子与当前容量的乘积时，则要对该哈希表进行rehash操作（即重建内部数据结构），从而哈希表将具有大约两倍的容量。
通常默认的加载因子为0.75，这是在时间和空间复杂度上的一种折中。加载因子过高尽管减少了空间开销，但同时也增加了查询成本（在大多数HashMap类的操作中，包括get和put操作）。在设置初始容量时应该考虑到映射中所需的条目数量以及加载因子，以便最大限度减少rehash操作次数。如果初始容量>(最大条目数/加载因子)，则不会发生rehash操作。

2> HashMap构造函数

 // 默认构造函数。public HashMap() {    // 设置“加载因子”    this.loadFactor = DEFAULT_LOAD_FACTOR;    // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。    threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);    // 创建Entry数组，用来保存数据    table = new Entry[DEFAULT_INITIAL_CAPACITY];    init();}// 指定“容量大小”和“加载因子”的构造函数public HashMap(int initialCapacity, float loadFactor) {    if (initialCapacity < 0)        throw new IllegalArgumentException("Illegal initial capacity: " +                                           initialCapacity);    // HashMap的最大容量只能是MAXIMUM_CAPACITY    if (initialCapacity > MAXIMUM_CAPACITY)        initialCapacity = MAXIMUM_CAPACITY;    if (loadFactor <= 0 || Float.isNaN(loadFactor))        throw new IllegalArgumentException("Illegal load factor: " +                                           loadFactor);    // Find a power of 2 >= initialCapacity    int capacity = 1;    while (capacity < initialCapacity)        capacity <<= 1;    // 设置“加载因子”    this.loadFactor = loadFactor;    // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。    threshold = (int)(capacity * loadFactor);    // 创建Entry数组，用来保存数据    table = new Entry[capacity];    init();}// 指定“容量大小”的构造函数public HashMap(int initialCapacity) {    this(initialCapacity, DEFAULT_LOAD_FACTOR);}// 包含“子Map”的构造函数public HashMap(Map<? extends K, ? extends V> m) {    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,                  DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);    // 将m中的全部元素逐个添加到HashMap中    putAllForCreate(m);}

3>HashMap的的重要特性

public class HashMap<K,V>      extends AbstractMap<K,V>      implements Map<K,V>, Cloneable, Serializable  {      // 系统默认初始容量，必须是2的n次幂，这是出于优化考虑的      static final int DEFAULT_INITIAL_CAPACITY = 16;      // 系统默认最大容量      static final int MAXIMUM_CAPACITY = 1 << 30;      // 系统默认负载因子0.75，可在构造函数中指定      static final float DEFAULT_LOAD_FACTOR = 0.75f;      // 用于存储的表，长度可以调整，且必须是2的n次幂      transient Entry[] table;      // 当前map的key-value映射数，也就是当前size      transient int size;      // 阈值      int threshold;      // 哈希表的负载因子      final float loadFactor;      // 用于确保使用迭代器的时候，HashMap并未进行更改      transient volatile int modCount;      // 构造一个带指定初始容量和加载因子的空 HashMap。      public HashMap(int initialCapacity, float loadFactor) {          // 如果指定初始容量小于0，抛错          if (initialCapacity < 0)              throw new IllegalArgumentException("Illegal initial capacity: " +                                                 initialCapacity);          // 如果初始容量大于系统默认最大容量，则初始容量为最大容量          if (initialCapacity > MAXIMUM_CAPACITY)              initialCapacity = MAXIMUM_CAPACITY;          // 如果loadFactor小于0，或loadFactor是NaN，则抛错          if (loadFactor <= 0 || Float.isNaN(loadFactor))              throw new IllegalArgumentException("Illegal load factor: " +                                                 loadFactor);          // 寻找一个2的k次幂capacity恰好大于initialCapacity          int capacity = 1;          while (capacity < initialCapacity)              capacity <<= 1;          // 设置负载因子          this.loadFactor = loadFactor;          // 设置阈值为capacity * loadFactor，实际上当HashMap当前size到达这个阈值时，HashMap就需要扩大一倍了。          threshold = (int)(capacity * loadFactor);          // 创建一个capacity长度的数组用于保存数据          table = new Entry[capacity];          // 开始初始化          init();      }  

结合上述代码，对其变量进行分析：
1>HashMap继承于AbstractMap类，实现了Map接口,Map是key-value键值对接口，AbstractMap实现了键值对的通用函数接口。
2>HashMapa是通过“拉链法”实现的哈希表。它包括几个重要的成员变量：table，size，threshold，loadFactor，modCount。
table：是一个Entry[]数组类型。而Entry、实际是一个单向链表。哈希标的键值对都是保存在Entry数组中的。
size：HashMap的大小，它是HashMap保存的键值对的数；
threshold是HashMap的阈值，用于判断是否需要调整HashMap的容量；
threshold=容量*加载因子，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍；
loadFactor就是加载因子；
modCount是用来实现fail-fast机制。

三、HashMap主要API

1>
clear():
用于清空HashMap。它是通过将所有的元素设为null来实现的。源码如下：

public void clear() {    modCount++;    Entry[] tab = table;    for (int i = 0; i < tab.length; i++)        tab[i] = null;    size = 0;}

2>containsKey()
用于判断HashMap是否包含key。源码如下：

public boolean containsKey(Object key) {    return getEntry(key) != null;}

由上面代码可以得到，首先通过getEntry（key）获取对应的Entry，然后判断该Entry是否为null，则getEntry（）源码如下：

final Entry<K,V> getEntry(Object key) {    // 获取哈希值    // HashMap将“key为null”的元素存储在table[0]位置，“key不为null”的则调用hash()计算哈希值    int hash = (key == null) ? 0 : hash(key.hashCode());    // 在“该hash值对应的链表”上查找“键值等于key”的元素    for (Entry<K,V> e = table[indexFor(hash, table.length)];         e != null;         e = e.next) {        Object k;        if (e.hash == hash &&            ((k = e.key) == key || (key != null && key.equals(k))))            return e;    }    return null;}

getEntry（）的作用就是返回键值为key的键值对。
注意点：HashMap将“key为null”的元素都放在table的位置0处，即table[0];key不是null的则放在其它处。
3>containsValue()
用于判断HashMap是否包含“值为value”的元素，源码如下：

public boolean containsValue(Object value) {    // 若“value为null”，则调用containsNullValue()查找    if (value == null)        return containsNullValue();    // 若“value不为null”，则查找HashMap中是否有值为value的节点。    Entry[] tab = table;    for (int i = 0; i < tab.length ; i++)        for (Entry e = tab[i] ; e != null ; e = e.next)            if (value.equals(e.value))                return true;    return false;}

由代码可以得出，containsValue()处理：一：若value为空，则调用containsNullValue()；二：若value不为null，则查找HashMap中是否有值为value的节点。
containsNullValue() 的作用判断HashMap中是否包含“值为null”的元素。

private boolean containsNullValue() {    Entry[] tab = table;    for (int i = 0; i < tab.length ; i++)        for (Entry e = tab[i] ; e != null ; e = e.next)            if (e.value == null)                return true;    return false;}

4>entrySet()、values()、keySet()
三者实现原理相似，以entrySet（）为例。
entrySet（）是返回“HashMap中所有Entry的集合”，它是一个集合。实现代码如下：

// 返回“HashMap的Entry集合”public Set<Map.Entry<K,V>> entrySet() {    return entrySet0();}// 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象private Set<Map.Entry<K,V>> entrySet0() {    Set<Map.Entry<K,V>> es = entrySet;    return es != null ? es : (entrySet = new EntrySet());}// EntrySet对应的集合// EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {    public Iterator<Map.Entry<K,V>> iterator() {        return newEntryIterator();    }    public boolean contains(Object o) {        if (!(o instanceof Map.Entry))            return false;        Map.Entry<K,V> e = (Map.Entry<K,V>) o;        Entry<K,V> candidate = getEntry(e.getKey());        return candidate != null && candidate.equals(e);    }    public boolean remove(Object o) {        return removeMapping(o) != null;    }    public int size() {        return size;    }    public void clear() {        HashMap.this.clear();    }}

HashMap是通过链表法实现的散列表。表现在HashMap包括许多的Entry，而每一个ENtry都是一个单向链表。当HashMap遍历key-value键值对时，是通过newEntryIterator()逐个去遍历实现的，代码如下：

// 返回一个“entry迭代器”Iterator<Map.Entry<K,V>> newEntryIterator()   {    return new EntryIterator();}// Entry的迭代器private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {    public Map.Entry<K,V> next() {        return nextEntry();    }}// HashIterator是HashMap迭代器的抽象出来的父类，实现了公共了函数。// 它包含“key迭代器(KeyIterator)”、“Value迭代器(ValueIterator)”和“Entry迭代器(EntryIterator)”3个子类。private abstract class HashIterator<E> implements Iterator<E> {    // 下一个元素    Entry<K,V> next;    // expectedModCount用于实现fast-fail机制。    int expectedModCount;    // 当前索引    int index;    // 当前元素    Entry<K,V> current;    HashIterator() {        expectedModCount = modCount;        if (size > 0) { // advance to first entry            Entry[] t = table;            // 将next指向table中第一个不为null的元素。            // 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。            while (index < t.length && (next = t[index++]) == null)                ;        }    }    public final boolean hasNext() {        return next != null;    }    // 获取下一个元素    final Entry<K,V> nextEntry() {        if (modCount != expectedModCount)            throw new ConcurrentModificationException();        Entry<K,V> e = next;        if (e == null)            throw new NoSuchElementException();        // 注意！！！        // 一个Entry就是一个单向链表        // 若该Entry的下一个节点不为空，就将next指向下一个节点;        // 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。        if ((next = e.next) == null) {            Entry[] t = table;            while (index < t.length && (next = t[index++]) == null)                ;        }        current = e;        return e;    }    // 删除当前元素    public void remove() {        if (current == null)            throw new IllegalStateException();        if (modCount != expectedModCount)            throw new ConcurrentModificationException();        Object k = current.key;        current = null;        HashMap.this.removeEntryForKey(k);        expectedModCount = modCount;    }}

当我们通过entrySet()获取到的Iterator的next()方法去遍历HashMap时，实际上调用的是 nextEntry() 。而nextEntry()的实现方式，先遍历Entry(根据Entry在table中的序号，从小到大的遍历)；然后对每个Entry(即每个单向链表)，逐个遍历。
5>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;        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))            return e.value;    }    return null;}

6>put()
用于对外提供接口，让HashMap对象通过put（）将键值对添加到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++;    addEntry(hash, key, value, i);    return null;}

若要添加到HashMap中的键值对对应的key已经存在HashMap中，则找到该键值对；然后新的value取代旧的value，并退出！
若要添加到HashMap中的键值对对应的key不在HashMap中，则将其添加到该哈希值对应的链表中，并调用addEntry()。
下面看看addEntry()的代码：

void addEntry(int hash, K key, V value, int bucketIndex) {    // 保存“bucketIndex”位置的值到“e”中    Entry<K,V> e = table[bucketIndex];    // 设置“bucketIndex”位置的元素为“新Entry”，    // 设置“e”为“新Entry的下一个节点”    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);    // 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小    if (size++ >= threshold)        resize(2 * table.length);}

此时就涉及到addEntry()和createEntry（）的区别。
a、addEntry（）一般用在新增Entry可鞥呢导致HahsMap实际容量超过阈值的情况。例：新建一个HashMap，然后不断通过put()向HashMap中添加元素；put()是通过addEntry()新增Entry的。
在这种情况下，我们不知道何时“HashMap的实际容量”会超过“阈值”；因此，需要调用addEntry()；
b、createEntry() 一般用在 新增Entry不会导致“HashMap的实际容量”超过“阈值”的情况下。例:调用HashMap“带有Map”的构造函数，它绘将Map的全部元素添加到HashMap中；
但在添加之前，我们已经计算好“HashMap的容量和阈值”。也就是，可以确定“即使将Map中的全部元素添加到HashMap中，都不会超过HashMap的阈值”。此时，调用createEntry()即可。
7>remove()
用于删除键为key的元素

public V remove(Object key) {    Entry<K,V> e = removeEntryForKey(key);    return (e == null ? null : e.value);}// 删除“键为key”的元素final Entry<K,V> removeEntryForKey(Object key) {    // 获取哈希值。若key为null，则哈希值为0；否则调用hash()进行计算    int hash = (key == null) ? 0 : hash(key.hashCode());    int i = indexFor(hash, table.length);    Entry<K,V> prev = table[i];    Entry<K,V> e = prev;    // 删除链表中“键为key”的元素    // 本质是“删除单向链表中的节点”    while (e != null) {        Entry<K,V> next = e.next;        Object k;        if (e.hash == hash &&            ((k = e.key) == key || (key != null && key.equals(k)))) {            modCount++;            size--;            if (prev == e)                table[i] = next;            else                prev.next = next;            e.recordRemoval(this);            return e;        }        prev = e;        e = next;    }    return e;}

四、HashMap的遍历方式

1、遍历HashMap的键值对

// 假设map是HashMap对象// map中的key是String类型，value是Integer类型Integer integ = null;Iterator iter = map.entrySet().iterator();while(iter.hasNext()) {    Map.Entry entry = (Map.Entry)iter.next();    // 获取key    key = (String)entry.getKey();        // 获取value    integ = (Integer)entry.getValue();}

2、遍历HashMap的键

// 假设map是HashMap对象// map中的key是String类型，value是Integer类型String key = null;Integer integ = null;Iterator iter = map.keySet().iterator();while (iter.hasNext()) {        // 获取key    key = (String)iter.next();        // 根据key，获取value    integ = (Integer)map.get(key);}

3、遍历HashMap的值

// 假设map是HashMap对象// map中的key是String类型，value是Integer类型Integer value = null;Collection c = map.values();Iterator iter= c.iterator();while (iter.hasNext()) {    value = (Integer)iter.next();}

五、HashMap用法实例

package Test;/** * Created by LKL on 2017/2/17. */import java.util.Map;import java.util.Random;import java.util.Iterator;import java.util.HashMap;/* * HashMap测试程序 */public class TestHashMap {    public static void main(String[] args) {        testHashMapAPIs();    }    private static void testHashMapAPIs() {        // 初始化随机种子        Random r = new Random();        // 新建HashMap        HashMap map = new HashMap();        // 添加操作        map.put("one", r.nextInt(10));        map.put("two", r.nextInt(10));        map.put("three", r.nextInt(10));        // 打印出map        System.out.println("map:"+map );        // 通过Iterator遍历key-value        Iterator iter = map.entrySet().iterator();        while(iter.hasNext()) {            Map.Entry entry = (Map.Entry)iter.next();            System.out.println("next : "+ entry.getKey() +" - "+entry.getValue());        }        // HashMap的键值对个数        System.out.println("size:"+map.size());        // containsKey(Object key) :是否包含键key        System.out.println("contains key two : "+map.containsKey("two"));        System.out.println("contains key five : "+map.containsKey("five"));        // containsValue(Object value) :是否包含值value        System.out.println("contains value 0 : "+map.containsValue(new Integer(0)));        // remove(Object key) ： 删除键key对应的键值对        map.remove("three");        System.out.println("map:"+map );        // clear() ： 清空HashMap        map.clear();        // isEmpty() : HashMap是否为空        System.out.println((map.isEmpty()?"map is empty":"map is not empty") );    }}

运行结果如下：

map:{one=9, two=4, three=1}next : one - 9next : two - 4next : three - 1size:3contains key two : truecontains key five : falsecontains value 0 : falsemap:{one=9, two=4}map is empty

文章只是作为自己的学习笔记，借鉴了网上的许多案例，如果觉得阔以的话，希望多交流，在此
谢过…