java.util.HashMap源码解析

1.java集合框架图


2.所属包

package java.util;

3.继承与实现关系

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

4.准备知识

HashMap是基于哈希表的非同步的实现,不保证映射的顺序永久不变,可以键值对都为null。哈希表的核心就是根据元素求位置。而多个元素可能出现相同的位置,那么就叫冲突。解决冲突的常用方式:链地址法:将多个值的不同的哈希结果(哈希值)用数组进行存储,然后将产生相同哈希值的元素,以单向链表的形式进行存储。所以拉链法的套路就是数组+单链表。第二种解决方式是线性探测法:将多个值余上表长度,如果多个值产生相同的哈希值,那么就依次往下寻找位置,直到不冲突为止。线性探测法致命的缺点就是当数据量上来时,就会频繁的进行碰撞冲突,然后找到位置比较费劲。


5.属性

/**
     * 默认初始化容量为16
     */
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * 最大容量,必须是2的n次幂
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 默认加载因子
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 存储数据的Entry数组,是存储实体的数组,长度是2的幂
     */
    transient Entry<K,V>[] table;

    /**
     * 映射键值对的个数,也是数组中元素的个数
     */
    transient int size;

    /**
     * 临界值,当实际大小超过临界值时,会进行扩容threshold = 加载因子*容量
     */
    int threshold;

    /**
     * 哈希表的加载因子
     */
    final float loadFactor;

    /**
     * 被修改的次数
     */
    transient int modCount;

6.HashMap中链地址的单链表结构

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;//指向下一个相同hash值得元素
        int hash;//哈希值

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

7.构造方法

/**构造方法1:
     * 初始化一个Entry数组,数组大小为2的n次幂
     */
    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次幂递增,这样保证了容量大小为偶数
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
	//以定义的容量capacity初始化Entry数组
        table = new Entry[capacity];
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        init();
    }

/**构造方法2
     * 使用默认的加载因子和初始化容量构造HashMap
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

/**构造方法3
     * 使用默认的初始化容量16,和默认的加载因子0.75构造HashMap
     */
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

/**构造方法4
     * 构造一个映射关系与指定 Map 相同的 HashMap。
	 * 所创建的 HashMap 具有默认的加载因子 (0.75) 和足以容纳指定 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);
        putAllForCreate(m);
    }

       //遍历m获取值,放入哈希表
    private void putAllForCreate(Map<? extends K, ? extends V> m) {
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            putForCreate(e.getKey(), e.getValue());
    }
private void putForCreate(K key, V value) {
	//如果键为空,hash值为0,如果键不为空,那么就通过键来生成hash值
        int hash = null == key ? 0 : hash(key);
	//通过hash值来获取索引
        int i = indexFor(hash, table.length);

        /**
         * 通过索引查找到table中的Entry节点,进行遍历单链表中的Entry节点。
		 * 如果出现了该索引对应hash值和键都相同的,那么就直接退出该方法。
         */
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                e.value = value;
                return;
            }
        }
	//否则就执行createEntry方法创建该桶
        createEntry(hash, key, value, i);
    }

8.方法

createEntry:

void createEntry(int hash, K key, V value, int bucketIndex) {
		//根据索引得出对应定义的Entry类型对象e
        Entry<K,V> e = table[bucketIndex];
		//将e进行初始化哈希值、键、值,以及单链表指向的下一个节点e
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }
如果没有相同的hash值和键,那么就会采用上面的方法来创建Entry。就是使用构造器初始化Entry。

hash:

/**
     * 根据键来获取对应的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值,方法首先是进行了hashcode方法先散列一次,然后再进行右移和异或运算。

indexFor:

/**
     * 返回hash值对应的索引。
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

在我们自己实现哈希表的时候,常常会采用取%的方式来进行散列,将余数作为散列码。但是java采用的是二进制与运算来取hash值。由于length为2的n次幂,所以其减一为奇数,那么转化为二进制,末位肯定是1。如果hash值h为奇数,那么h与length的与运算,返回索引的二进制末位为1.如果hash值h为偶数,那么h与length的与运算,返回索引的二进制末位为0。这就相当于取模运算了,但是与位运算比取模速度快很多。并且这样也可以保证数组的下标不会越界。是一个很棒的选择。由于与运算加上前面hash(key)函数的高位运算,就减少了碰撞。这样就保证了hash值分布比较均匀并且冲突的概率很低。并且只有在值相同时,才会对应数组中的相同位置Entry,然后以next的形式构成链表。


put方法:

/**
     * 将指定值与此映射中指定的键关联。如果映射以前包含了键的映射,则替换旧值。
     */
    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
	//通过键获取hash值
        int hash = hash(key);
	//通过hash值获取下标索引
        int i = indexFor(hash, table.length);
	/**
	* 如果hash值和键都相同的话,那么就返回对应的旧的值。
	* 然后新值覆盖旧值。
	*/
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            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);
        return null;
    }

 /**
     * 如果当键为空时且键相同,就查找表,如果值也相同,那么就返回旧值。
	 * 否则就添加新值且返回空
     */
    private V putForNullKey(V value) {
        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++;
        addEntry(0, null, value, 0);
        return null;
    }
addEntry方法:
/**
     * 添加新的值
     */
    void addEntry(int hash, K key, V value, int bucketIndex) {
		/** 
		 * 映射键值对数目超出了临界值的情况。
	         * 创建新表容量为原来旧表的二倍,将旧表元素转移到新表。
		 * 然后通过键生成新的hash值。
		 * 然后通过新的hash值获取对应的下标索引
		*/
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
	//通过新的hash值、键、值、下标索引来以构造器的方式创建Entry
        createEntry(hash, key, value, bucketIndex);
    }
resize方法:
/**
     * 就是将HashMap就行扩容操作
     */
    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];
        boolean oldAltHashing = useAltHashing;
        useAltHashing |= sun.misc.VM.isBooted() &&
                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean rehash = oldAltHashing ^ useAltHashing;
	//定义了新容量的数组,那么这步就是将旧容量数组中的元素都放到新容量的数组中去
        transfer(newTable, rehash);
	//然后更新当前的Entry数组,也可以说更新桶
        table = newTable;
	//然后临界值也由新容量进行调整
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }
transfer方法:

/**
     * 将旧表中的元素都转移到新表中
     */
    void transfer(Entry[] newTable, boolean rehash) {
	//获取新表的容量
        int newCapacity = newTable.length;
	//遍历旧表中的Entry,然后通过旧表中的Entry创建新表的Entry。
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
		//如果需要就重新通过键生成hash值
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
		//通过hash值获取下标索引
                int i = indexFor(e.hash, newCapacity);
		//设置当前Entry节点e指向的下一个节点Entry值为newTable[i]
                e.next = newTable[i];
		//将遍历到的Entry作为新表下标索引对应的值
                newTable[i] = e;
		//单链表循环的条件
                e = next;
            }
        }
    }
可以看到为了转移元素,使用旧的值生成hash值,再重新计算下标索引的位置,用了两层循环,时间复杂度增加了数量级,非常消耗性能。所以如果我们已知了需要的空间,那么就会减少不必要的因为超出的原因产生的扩容操作,减少了性能的消耗。


get方法:

/**
     * 当键为空的时候,就遍历桶,然后找出键为空对应的值。
	 * 如果键不为空,就通过键生成hash值,再通过hash值生成下标索引,遍历下标索引对应的Entry单链表,获取到hash值和键相同的对应的元素
	 * 如果查询到的Entry为null那么就返回null,否则返回Entry对应的值。
     */
    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }
	
	/**
     * Returns the entry associated with the specified key in the
     * HashMap.  Returns null if the HashMap contains no mapping
     * for the key.
     */
    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;
    }

9.巧妙的设计

<1>.通过的表长为2的n次幂

<2>.可以通过键获取hash值(hash方法)

<3>.可以通过hash值来获取下标索引(indexFor方法)

<4>.通过下标索引找到对应的Entry值,通过Entry值可以单链表的遍历方式或者hash值方式来找到哪些冲突的值。

<5>.put操作,如果旧空间不够,那么就扩容为原来的2倍,然后将旧元素移动到新空间。

10.参考文章

深入Java集合学习系列:HashMap的实现原理

通过分析 JDK 源代码研究 Hash 存储机制




-----------------------------该源码为jdk1.7版本的





评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值