hashMap（1.7）底层实现原理

最新推荐文章于 2023-08-01 19:34:07 发布

月如梭

最新推荐文章于 2023-08-01 19:34:07 发布

阅读量1k

点赞数

分类专栏： javaSe 文章标签： hashMap

javaSe 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

（1）hashMap的定义
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
HashMap继承自AbstractMap，AbstractMap是Map接口的骨干实现，AbstractMap中实现了Map中最重要最常用和方法，这样HashMap继承AbstractMap就不需要实现Map的所有方法，让HashMap减少了大量的工作。
而在这里仍然实现Map结构，没有什么作用，应该是为了让map的层次结构更加清晰

（2）HashMap的成员变量

int DEFAULT_INITIAL_CAPACITY = 16：默认的初始容量为16 
int MAXIMUM_CAPACITY = 1 << 30：最大的容量为 2 ^ 30 
float DEFAULT_LOAD_FACTOR = 0.75f：默认的加载因子为 0.75f 
Entry< K,V>[] table：Entry类型的数组，HashMap用这个来维护内部的数据结构，它的长度由容量决定 
int size：HashMap的大小 
int threshold：HashMap的极限容量，扩容临界点（容量和加载因子的乘积）

（3）HashMap的四个构造函数

public HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap 
public HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap 
public HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap 
public HashMap(Map< ? extends K, ? extends V> m)：构造一个映射关系与指定 Map 相同的新 HashMap

两个很重要的参数：
initialCapacity（初始容量）：是哈希表中桶的数量，初始容量只是哈希表在创建时的容量，实际上就是Entry< K,V>[] table的容量

loadFactor（加载因子）：是哈希表在其容量自动增加之前可以达到多满的一种尺度
当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

（4）hashMap 的数据结构
hashMap 1.7 的数据结构是数组 + 链接实现的。底层实现还是数组，只是数组中的每一项是链表。如图
这里写图片描述

（5）源码分析：
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;
        //加载因子不能<=0 或者 为非数字
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        //计算出大于初始容量的最小 2的n次方作为哈希表table的长度，下面会说明为什么要这样
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        //设置HashMap的容量极限，当HashMap的容量达到该极限时就会进行扩容操作
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        //创建Entry数组
        table = new Entry[capacity];
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        init();
    }

做了三件事：
（1）对传入的容量和加载因子进行判断处理
（2）设置hashMap的容量极限，当容量达到极限时就会进行扩容操作
（3）计算出大于初始容量的最小 2的n次方作为哈希表table的长度，然后用该长度创建Entry数组（table）

* 一个 hashMap 对应一个 Entry 数组， Entry 元素的内部结构如下*



static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

Entry 是 HashMap的内部类，维护着一个key -value 映射关系，还有next 引用（指向当前table 位置的链表）， hash值（用来确定每一个 Entry 链表在 table 中的位置）

* hashMap 的存储操作 put(k , value) *


public V put(K key, V value) {
        //如果key为空的情况
        if (key == null)
            return putForNullKey(value);
        //计算key的hash值
        int hash = hash(key);
        //计算该hash值在table中的下标
        int i = indexFor(hash, table.length);
        //对table[i]存放的链表进行遍历
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //判断该条链上是否有hash值相同的(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;
            }
        }

        //修改次数+1
        modCount++;
        //把当前key，value添加到table[i]的链表中
        addEntry(hash, key, value, i);
        return null;
    }

如果key 为 null，则调用 putForNullKey() 方法，这就是为什么null 可以做为键的原因，看下面代码了解 hashMap是怎么处理 null 键的。

 private V putForNullKey(V value) {
        //查找链表中是否有null键
        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;
            }
        }
        modCount++;
        //如果链中查找不到，则把该null键插入
        addEntry(0, null, value, 0);
        return null;
    }

 void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            //这一步就是对null的处理，如果key为null，hash值为0，也就是会插入到哈希表的表头table[0]的位置
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }

如果键中存在该 key , 则传入的 value 覆盖掉旧的value, 同时把旧的 value返回

计算 key 的hash 值

    final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

计算该 hash 值在 table 中的下标

static int indexFor(int h, int length) {
        return h & (length-1);
 }

上面已经获得了hash值，并且用该hash值知道了在table中的下标，接下来就是把 key, value 添加进索引的链表。调用addEntry(hash, key, value, i) 方法。

void addEntry(int hash, K key, V value, int bucketIndex) {
        //如果size大于极限容量，将要进行重建内部数据结构操作，之后的容量是原来的两倍，并且重新设置hash值和hash值在table中的索引值
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        //真正创建Entry节点的操作
        createEntry(hash, key, value, bucketIndex);
    }

  void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

取得bucketIndex位置的Entry头结点，并创建新节点，把该新节点插入到链表中的头部。
该新节点的next指针指向原来的头结点。

这里有两点需要注意：
一、链的产生
　　这是一个非常优雅的设计。系统总是将新的Entry对象添加到bucketIndex处。如果bucketIndex处已经有了对象，那么新添加的Entry对象将指向原有的Entry对象，形成一条Entry链，但是若bucketIndex处没有Entry对象，也就是e==null,那么新添加的Entry对象指向null，也就不会产生Entry链了。

二、扩容问题
　　还记得HashMap中的一个变量吗，threshold，这是容器的容量极限，还有一个变量size，这是指HashMap中键值对的数量，也就是node的数量
threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);

存储总结：
1. 传入key和value，判断key是否为null，如果为null，则调用putForNullKey，以null作为key存储到哈希表中；
2. 然后计算key的hash值，根据hash值搜索在哈希表table中的索引位置，若当前索引位置不为null，则对该位置的Entry链表进行遍历，如果链中存在该key，则用传入的value覆盖掉旧的value，同时把旧的value返回，结束；
3. 否则调用addEntry，用key-value创建一个新的节点，并把该节点插入到该索引对应的链表的头部

hashMap 的 get 实现

  public V get(Object key) {
        //如果key为null，求null键
        if (key == null)
            return getForNullKey();
        // 用该key求得entry
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : 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;
    }

读取步骤：（1）如果 key 为 null, 求null 键（2）key 不为null , 调用hash(key) ,求得key对应的hash值，然后调用indexFor(hash) 求得hash 值对应的table的索引位置，然后遍历索引位置的链表，如果存在key, 则把key 对应的Entry 返回，否则返回null 。

　　
　hashMap的遍历 keySet()
　核心代码如下：

 private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K,V> next;        // next entry to return
        int expectedModCount;   // For fast-fail
        int index;              // current slot
        Entry<K,V> current;     // current entry

        //当调用keySet().iterator()时，调用此代码
        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                //从哈希表数组从上到下，查找第一个不为null的节点，并把next引用指向该节点
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        //当调用next时，会调用此代码
        final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();

            //如果当前节点的下一个节点为null，从节点处罚往下查找哈希表，找到第一个不为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;
        }
    }