Java集合系列（6）--HashMap

最新推荐文章于 2022-12-06 18:22:53 发布

一只逗比的程序猿

最新推荐文章于 2022-12-06 18:22:53 发布

阅读量783

点赞数

分类专栏： java java基础 Java集合系列文章标签： java hashmap

本文链接：https://blog.csdn.net/L_kanglin/article/details/55532242

版权

java 同时被 3 个专栏收录

28 篇文章 0 订阅

订阅专栏

java基础

21 篇文章 0 订阅

订阅专栏

Java集合系列

12 篇文章 0 订阅

订阅专栏

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

前面，我们已对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 - 9
next : two - 4
next : three - 1
size:3
contains key two : true
contains key five : false
contains value 0 : false
map:{one=9, two=4}
map is empty