HashMap源码分析

最新推荐文章于 2025-01-12 06:54:12 发布

Mr-Yyt

最新推荐文章于 2025-01-12 06:54:12 发布

阅读量259

点赞数

CC 4.0 BY-SA版权

分类专栏： Java核心文章标签： java8 hashmap 源码解析

本文链接：https://blog.youkuaiyun.com/day_day_up_up_up/article/details/76991320

Java核心专栏收录该内容

10 篇文章

订阅专栏

源码版本

Java8

HashMap特点

采用键值对(key-value)存储;
HashMap中的数据结构是数组(哈希表)+单链表 + (红黑树)的组合。

概念

HashMap中，对象如何比较？在HashMap中，判断两个对象是否相等的规则是：

判断两个对象的hashCode是否相等
- 如果不相等，认为两个对象也不相等，return返回
- 如果相等，转入下一步
判断两个对象用equals运算是否相等如果不相等，认为两个对象也不相等如果相等，认为两个对象相等

这里也就是说两个对象的hashcode相等，对象不一定相等，还要使用equals方法区比较，若两个对象相等，那么它们的HashCode一定相等。

HashMap类定义

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

继承抽象类AbstractMap<K,V>，提供了map的部分实现；
实现Map<K,V>接口，实现Cloneable，Serializable接口，能够进行克隆拷贝，序列化。

HashMap类中属性

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
    static final int MAXIMUM_CAPACITY = 1 << 30;
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    static final int TREEIFY_THRESHOLD = 8;
    static final int UNTREEIFY_THRESHOLD = 6;
    static final int MIN_TREEIFY_CAPACITY = 64;

DEFAULT_INITIAL_CAPACITY
默认初始容量，当实例化对象时，未设置，则默认为16
MAXIMUM_CAPACITY
最大容量，若构造时，传入值过大，则将被该值替换，同时，当传入值大于MAXIMUM_CAPACITY，必须为2的偶数次幂，否则，报出异常Illegal initial capacity
DEFAULT_LOAD_FACTOR
默认负载值，实例化对象时，构造函数未指定，默认为0.75。该值表示含义，决定map容量扩容，当默认为HashMap(16, 0.75),默认容量为16，负载因子为0.75，当容量用到了16 * 0.75=12就进行扩容。若负载因子为1，就是16*1=16,当容量用到16才扩容。

在Java8中加入红黑树，又添加了如下属性

static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;

-- TREEIFY_THRESHOLD
当链表长度大于该值时，转换为红黑树

Map对象中节点存在数据结构Node<K,V>

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

Node<K,V>实现的是Map.Entry<K,V>，这里就是存入Map对象中节点的存储形式，Map是由数组，链表构成，这样的Node在LinkedList中也出现过，只不过属性值不同，多了hash值。这里重写了HashCode()方法，与equals()方法，用于判断节点是否相同。
当两个元素的hashcode值相同时，该怎么办？
它们会储存在同一个bucket位置的链表中。键对象的key.equals(k)方法用来找到键值对,该方法在Node<K,V>中重写了。
当两个对象的hashcode相同会发生什么？
它们的bucket位置相同，‘碰撞’会发生。因为HashMap使用链表存储对象，这个Entry(包含有键值对的Map.Entry对象)会存储在链表中。HashCode相同，会存储在同一个链表中。

存储原理

哈希表的实现是个数组，每个值都会通过散列函数来获取对应的数组下标，从而存在数组的相应位置。一旦两个值的哈希值相同，就会用链表连接起来。如上图是通过对数组长度求模的值来获取下标。然后再遍历这个单链表，去寻找对应key值的value。

HashMap构造方法

public HashMap(int initialCapacity)

    public HashMap()

    public HashMap(Map<? extends K, ? extends V> m)

    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;
        this.threshold = tableSizeFor(initialCapacity);
    }

public HashMap(int initialCapacity, float loadFactor)
构造函数，传入初始容量与负载因子。
public HashMap(Map<? extends K, ? extends V> m)
向构造方法中传入一个map,调用putMapEntries()方法，将其存入Map中，先计算容量，将传入Map的size除以负载因子，即为实际的Capacity，再调用tableSizeFor()方法,求出threshold。

HashMap核心方法

获取方法

public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

public V get(Object key);
通过key获取，Map中对应的Value，主要是调用getNode(int hash, Object key);方法实现。
这里传入的是通过key.hashCode()获取的Hash值。getNode()方法中，会先判断维护的table是否为空，然后再去判断first节点（为什么先要去判断first节点）；接着就是遍历，通过比较传入的hash值，确定所在的数组，再调用equals()去比较key。

添加元素

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

通过hash(key)计算出hash值，使用i = (n - 1) & hash计算在table中的下标，就相当于使用 (hash%tab.length),将该值存入对应的哈希表tab[i]中
如果该对应的单链表中为空，则直接新建一个节点，存入tab[i]中，如果对应不为空，则知道该单链表的tab[i].next为空时，存入
如果添加导致链表过长(>= TREEIFY_THRESHOLD)，就把链表转换成红黑树；
如果节点已经存在就替换old value(保证key的唯一性)
如果tab[]满了(超过load factor*current capacity)，就要resize。

测试

通过Debug，可以清楚看到维护的Map对象中属性值。

public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		
		map.put("1", "aaa");
		map.put("2", "bbb");
		map.put("3", "ccc");
		map.put("4", "ddd");
		map.put("5", "eee");
		map.put("6", "fff");
		map.put("7", "ggg");
		map.put("8", "hhh");
		map.put("9", "jjj");
		map.put("10", "kkk");
		map.put("11", "lll");
		map.put("12", "mmm");
		map.put("13", "nnn");
		for(Entry<String, String> e : map.entrySet())
		{
			System.out.println(e.getKey() + "=" + e.getValue() );
		}
	}

其中通过i = (n - 1) & hash中计算得来，i = (16 - 1) & 49 = 1，所以存储在tab[1]中，由于该位置没有值，所以直接新建存放在该tab[1]中，若已经存在值，则需要利用p = tab[1]，p.next进行遍历，这里是维护了一个单链表。

总结

HashMap原理

内部通过维护数组(哈希表)+单链表(红黑树)的组合
用哈希桶来形容很贴切，
存入数据时，先通过过传入的hash(Key)，判断是哪个桶，找到指定的桶，就把数据放进去。桶里面有个单链表。
当桶的容量，大于负载因子*current capacity时，扩容为2倍。获取元素时，计算出传入Key的Hash值，先定位到第一个哈希桶，然后以链表遍历桶里所有元素，逐个比较其key值
在JDK8里，新增默认为8的閥值，当一个桶里的Entry超过閥值，就不以单向链表而以红黑树来存放以加快Key的查找速度。

为什么要使用hashcode？

hashCode是用来在散列存储结构中确定对象的存储地址。 HashMap就是一个大内存块，里面有很多小内存块，小内存块里面是一系列的对象，可以利用hashCode来查找小内存块hashCode%size(小内存块数量)

如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？

随着HashMap中元素的数量越来越多，发生碰撞的概率就越来越大，所产生的链表长度就会越来越长，这样会影响HashMap的速度，为了保证HashMap的效率，系统必须要在某个临界点进行扩容处理。该临界点在当HashMap中元素的数量等于table数组长度*加载因子。
每次扩大容量，为2的n次方。不同的hash值发生碰撞的概率比较小，这样就会使得数据在table数组中分布较均匀，查询速度也较快。能够采用位运算，效率要高于做除法。

HashMap和HashTable有什么区别？

HashMap是支持null键和null值的，而HashTable在遇到null时，会抛出NullPointerException异常。HashMap中，key为null时，计算所得Hashcode为0。
Hashtable默认的初始大小为11，之后每次扩充为原来的2n+1。HashMap默认的初始化大小为16，之后每次扩充为原来的2倍。
Hashtable是线程安全的，HashMap不是。Hashtable中方法采用synchronized修饰。