HashMap

最新推荐文章于 2022-03-28 21:20:58 发布

丶2p

最新推荐文章于 2022-03-28 21:20:58 发布

阅读量139

点赞数 1

分类专栏： Java基础面试前夜文章标签：面试前夜

本文链接：https://blog.csdn.net/wy9717/article/details/80151749

版权

面试前夜同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

Java基础

7 篇文章 0 订阅

订阅专栏

HashMap一直是一个使用率极高的数据数据类型，用于映射处理，1.8的jdk改动，hashMap也有很大影响。今天我们根据源码，看看HashMap的存储结构、内部功能，也大致比较一下1.8和1.7的区别。

我们今天要时候的HashMap，是根据键的hashCode值存储数据的，什么是哈希表呢？

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

因为HashMap使用的是HashCode存储键，一般可以根据key直接定位到对应的value，所以具有很强的快速访问能力，不考虑哈希冲突的情况下，仅需一次定位即可完成，时间复杂度为O(1)。HashMap允许以null为key存值，但只允许一次。HashMap非线程安全，要是想要在多线程下使用，可以使用ConcurrentHashMap。

HashMap类：

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
{

Java为数据结构的映射定义了一个接口Java.util.Map,此接口主要有四个常用实现类HashMap、Hashtable、LinkedHashMap和TreeMap，下图可以理解他们之间的关系（网上拿的）：

java.util.map类图

存储结构

当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。哈希冲突的解决方案有多种:再散列函数法、链地址法。而HashMap即是采用了链地址法，也就是数组+链表的方式。（1.8加了红黑树）。HashMap主体是一个数组，当要查找或者添加时，如果定位的地方只有数组，那么添加和删除都很快，时间复杂度为O(1)；如果定位的地方含有链表，添加会在链表的头部添加，时间复杂度依然是O(1),但是查找则需要遍历整个链，相对较慢，所以一个HashMap中，链越少越好。我们先来看一张图帮助具象化理解HashMap的内部结构：

1.8中，当一个桶内键值对的个数大于8时，会转为红黑树。

1.8中，桶内装的对象叫做Node ,本质和Entry是一个东西。多了些get set和equals

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;
        }

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

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

经过上面初步了解，我们已经知道了 bucket，table，Entry（Node），下面我们来了解一下HashMap类中几个关键的字段。

先从构造方法入手，HashMap一共提供了四种构造方法：

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        this.loadFactor = loadFactor;
        threshold = initialCapacity;
        init();
    }

   
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

 
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

   
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        inflateTable(threshold);

        putAllForCreate(m);
    }

从构造方法可以看出，主要干的事就两个：1.参数是否合法。2.改变静态变量的值。

设计到的重要的变量一共有:

loadFactor，threshold , default_initial_capacity, default_loadFactor, max_capacity

查看源码我们看到类中的字段：

 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
 static final int MAXIMUM_CAPACITY = 1 << 30;
 static final float DEFAULT_LOAD_FACTOR = 0.75f;
 transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
 transient int size;
 int threshold;
 final float loadFactor;
 transient int modCount;

上图提到，table就是个Entry数组，capacity是指table的长度，默认是16，最大是1<<30。在HashMap中，哈希桶数组table的长度大小必须为2的n次方，

int capacity = roundUpToPowerOf2(toSize);

 private static int roundUpToPowerOf2(int number) {
        // assert number >= 0 : "number must be non-negative";
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }

这个判定真的很有用，相当于在后面取模，扩容时做了优化。

modCount是指当前map内部结构改变的次数。（值改变不是内部结构改变，只有put或者remove等改变键值对的时候才是内部结构的改变）

size这个字段其实很好理解，就是HashMap中实际存在的键值对数量

重点是剩下的几个：

threshold（阀值）: 是指map对象能容纳的键值对的最大个数，当HashMap大小大于阀值，HashMap将扩容两倍（稍后细讲扩容）

 threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);

也就是说：当table数组的长度确定之后，负载因子越大，能容纳的键值对越多。

loadFactor：负载因子，默认值为0.75,建议不要修改，除非情况很特殊，如果你内存空间充裕，追求时间效率，可以降低负载因子的值，反之，增大负载因子，这个值可以大于1.

对于红黑树，说实话，很有效，也很麻烦，想了解的来这里：初步了解红黑树

内部方法

HashMap的内部方法有挺多的，其中以put最为典型，这次我们就以put方法来进行分析，1.8中因为加入了红黑树，所以代码拉长了很多，思路与1.7中还是一致的，为了简洁，我们这次以1.7的源码为例分析。

public V put(K key, V value) {

        //如果table为空数组，则为table分配一个默认大小的空间（1<<4=16）
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }

        //如果key为null，则存储在table[0]，或者table[0]所在的链上
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);//对key的hashcode进行重新计算，保证散列是均匀的
        int i = indexFor(hash, table.length);//定位当前entry在table中的实际位置
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;//如果要put的数据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;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);//如果要put的entry不存在，则新增一个entry
        return null;
    }

inflateTable：

private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize
        int capacity = roundUpToPowerOf2(toSize);//上文提到，保证capacity是2的n次幂
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//除非你特意的改变负载因子（loadFactor）的值>1,不然capacity的值不会大于Max,所以多数情况下去的是前者，两个的乘积
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

计算hashCode，运用了很多位运算，hash（）：

1.7：

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

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

1.8：

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

不管是添加，删除，还是查找，定位桶的位置都是很关键的，也是要做的第一步。我们看看定位的方法：indexFor：

 static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);
    }

上面提到，因为hashMap是数据+链表，所以我们希望HashMap里面的元素分布的尽量均匀一些，也就是说一个桶中的元素尽可能的少，这样我们就可以定位到桶以后直接获得元素，而不需要遍历链表，使查询速度大大加快。所以定位数组索引的位置，直接决定hashMap的性能。因为相同的hashCode经过hash之后得到的值是相同的，我们希望这个hash值能在数组中均匀的分布，第一想到的就是对数组的长度进行取模，也就是hash%length（capacity），但是取模这个操作对性能影响是比较大的，而HashMap中是这样做的 hash&（length-1），因为length一定是2的n次幂，所以hash&（length-1）等价于hash对length取模：我们来看个例子，假如hash值是7，数组长度legth为4，那么取模就是7%4=3，当我们用位与（&）的时候是这样的：

结果相同，但是位运算比取模的效率要高上许多。

上面的方法说完了，我们来看看put方法里的最后一个方法，addEntry:

 void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {//当size超过阀值时，对HashMap进行扩容，新的容量为原来的二倍
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);//扩容之后重新定位当前entry所在索引位置
        }

        createEntry(hash, key, value, bucketIndex);//把entry放到定位之后的位置
    }

 void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable, initHashSeedAsNeeded(newCapacity));//将就数组内的元素放到扩容后的数组中！！！
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);//重新计算阀值
    }

void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {//遍历旧的table
            while(null != e) {//将旧数组中每个索引位置上的所有键值对，放到新的数组上
                Entry<K,V> next = e.next;//先保存下一次要处理的键值对
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);//计算当前entry在新数组中应在在的索引位置（这意味着，新数组中的键值对放置的位置与原数组是不用的）
                e.next = newTable[i];//如果新数组对应索引位置没有数据，相当于把当前键值对的next置空，如果有数据，则当前键值对的next指向它。
                newTable[i] = e;//定位的索引位置的数据改为当前键值对，相当于在新数组的当前索引的头部添加键值对
                e = next;//遍历下一个键值对
            }
        }
    }

单纯地文字描述，理解有点吃力，看看图：

我们假设旧数组长度为2，负载因子为1。因为扩容不涉及value，我们只用key表示键值对，旧的数组中有三个数据，key分别为3.5.7，hash（）之后都应定位在table[1]上，所以内部结构为：

下面我们进行扩容：

1.新建一个table，长度为4，其中每个索引位置对应的数据都为null；即newtable[i]=null;

遍历oldtable；table[0]没有数据，table[1]中先从entry-3开始，所以上述代码中e为entry-3，next=e.next为entry-5；重新计算新数组中的索引位置，

                int i = indexFor(e.hash, newCapacity);//3&（4-1）=3 ，所以存放在newtable[3]下，

                e.next = newTable[i]; //newTable[3]为null，所以e.next=null;

                newTable[i] = e;//将当前键值对放到新数组定位的索引位置

                e = next;//遍历下一个键值对

,第二次遍历，e为entry-5，对应的新的table中的存放位置应该是newtable[1]；步骤和上述一样，结果为：

当遍历entry-7时，计算对应的新的table的存放位置为newtable[3],当前位置已经有了entry-3，所以

 e.next = newTable[i];// newTable[3]为entry-3，所以e.next=entry-3

 newTable[i] = e; //新数组索引3的位置替换为entry-7

至此，遍历结束：最终的内部结构就如上图所示，经过新旧数组对比，可以得到两点：

1.新旧数组中对应键值对的位置可能不同

2.还在同一索引位置的键值对顺序发生的倒转。（3-7变为7-3）；

我们再来看看1.8中被优化的扩容（自己思考真的好麻烦，我借鉴网上大神的图和思路）：

上面提到，因为数组的长度都是2的n次幂，所以新的数组中元素的位置要么是原位置，要么是原位置在移动2次幂的位置

示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。

hashMap 1.8 哈希算法例图1

元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化： hashMap 1.8 哈希算法例图2

因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：

jdk1.8 hashMap扩容例图

总体就是这样，想深究的去看看源码吧，好长，我就不在这摆摆了。

总之，1.8与1.7相比，性能得到了很大的优化，尤其是当数组中的链表较长时，红黑树大大提高了访问的效率。当然，HashMap是非线程安全的，所以，多线程情况下还是不推荐使用。就说这么多。

丶2p

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
HashMap

HashMap一直是一个使用率极高的数据数据类型，用于映射处理，1.8的jdk改动，hashMap也有很大影响。今天我们根据源码，看看HashMap的存储结构、内部功能，也大致比较一下1.8和1.7的区别。我们今天要时候的HashMap，是根据键的hashCode值存储数据的，什么是哈希表呢？散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行...
复制链接

扫一扫

专栏目录