浅谈HashMap（基于JDK1.7）

最新推荐文章于 2025-04-30 18:12:19 发布

是南瓜吧

最新推荐文章于 2025-04-30 18:12:19 发布

阅读量168

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.youkuaiyun.com/weixin_44809858/article/details/118722818

版权

Java 专栏收录该内容

4 篇文章

订阅专栏

浅析HashMap（基于JDK1.7）

HashMap基于JDK1.7的类定义

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

HashMap的数据结构

HashMap才用的数据结构是数组+链表的组合方式
为了解决hash冲突使用的是拉链法，即遇到hash冲突的时候通过在数组上挂载链表来解决hash冲突

通过示意图直观的对hashmap数据结构进行说明

3.源码解析

hashmap的初始关键字

//map 初始化容量，即数组大小
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;
//承载量=容量*加载因子
int threshold;
//加载因子
final float loadFactor;
//map结构变更过的次数
transient int modCount;
//声明的表，初始化为空
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
// key-map键值对的个数，不能大于承载量
transient int size;

对于new方法的解析

public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
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;//初始化承载量，16
    init();//供子类扩展的方法
}

对于put方法的解析
put方法，其引出的hash方法，putForNullKey等等都基于put方法

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {//首先判断数组是否被初始化，若没有被初始化，执行初始化步骤
        inflateTable(threshold);//初始化table数组，方法在下方可找
    }
    if (key == null)
    	//如果key为空，则调用putForNullKey方法，保存null于table第一个位置中，这是HashMap允许为null的原因 
        return putForNullKey(value);
    int hash = hash(key);//根据key求出hash值
    int i = indexFor(hash, table.length);//求出在数组中的位置
    for (HashMap.Entry<K,V> e = table[i]; e != null; e = e.next) {//遍历链表找出对应的key，覆盖原有的value
        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;
        }
    }
    //如果没找到，则新增一个Entry,结构改变，modCount加一	
    modCount++;
    addEntry(hash, key, value, i);//源码解释在下面
    return null;
}

//初始化数组，对其进行初始化操作，
private void inflateTable(int toSize) {
		//capacity一定是2的次幂，为什么是2的次幂，只要是因为2的次幂能有效的减少hash冲突
        int capacity = roundUpToPowerOf2(toSize);
        //此处为threshold赋值，取capacity*loadFactor和MAXIMUM_CAPACITY+1的最小值，
        //capaticy一定不会超过MAXIMUM_CAPACITY，除非loadFactor大于1
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];//对其进行空间分配
        initHashSeedAsNeeded(capacity);//选择合适的Hash因子
    }

//主要就是为了是其数组数值可以是最接近的2的次幂
private static int roundUpToPowerOf2(int number) {
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }

//hash算法，纯数学思想，看看就完事了
static int hash(int h) {  
        h ^= (h >>> 20) ^ (h >>> 12);  
        return h ^ (h >>> 7) ^ (h >>> 4);  
 }  
 
//这个地方是计算数据插入的数组下标，为什么是与运算要与数组长度-1呢？
//问题就是在于在与运算中，只有都是两位都是1，才能为1，否则为0，这里就出现了一个问题
//比如我们与上数组实际长度，那么就会出现，最后一位永远是0，到时数据分布不均匀
static int indexFor(int h, int length) {  
        return h & (length-1);  
 }  

//在遍历完链表之后，如果没有这个要插入的，就新建一个entry，并且是以头插法的方式将数据插入到链表之中
void addEntry(int hash, K key, V value, int bucketIndex) {  
        //获取bucketIndex处的Entry  
        Entry<K, V> e = table[bucketIndex];  
        //将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry   
        table[bucketIndex] = new Entry<K, V>(hash, key, value, e);  
        //若HashMap中元素的个数超过极限了，则容量扩大两倍  
        if (size++ >= threshold)  
            resize(2 * table.length);  
 }  

//扩容操作  
    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;//修改HashMap的底层数组  
        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) { //遍历所有桶
            while(null != e) {  //遍历桶中所有元素（是一个链表）
                Entry<K,V> next = e.next; 
                //如果是重新Hash，则需要重新计算hash值  
                //这里需要着重注意，因为在1.8之后对元素的操作发生了根本的变化 
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);  
                }  
                int i = indexFor(e.hash, newCapacity);//定位Hash桶  
                e.next = newTable[i];//元素连接到桶中,这里相当于单链表的插入，总是插入在最前面
                newTable[i] = e;//newTable[i]的值总是最新插入的值
                e = next;//继续下一个元素  
            }  
        }  
    }


//获取key值为key的元素值  这个地方就没什么好说的，可以直接看下代码，每条已经加了注释
    public V get(Object key) {  
        if (key == null)//如果Key值为空，则获取对应的值，这里也可以看到，HashMap允许null的key，其内部针对null的key有特殊的逻辑  
            return getForNullKey();  
        Entry<K,V> entry = getEntry(key);//获取实体  

        return null == entry ? null : entry.getValue();//判断是否为空，不为空，则获取对应的值  
    }  

    //获取key为null的实体  
    private V getForNullKey() {  
        if (size == 0) {//如果元素个数为0，则直接返回null  
            return null;  
        }  
        //key为null的元素存储在table的第0个位置  
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {  
            if (e.key == null)//判断是否为null  
                return e.value;//返回其值  
        }  
        return null;  
    }

1.7的HashMap在多线程下的问题

这里主要是说了在多线程情况下，链表使用头插法会出现的问题，其实我认为这也不算是什么问题，因为自始至终从来没有说过在多线程的情况下使用HashMap，本就是线程不安全的类，为什么要在多线程的情况下使用它呢？
使用头插法容易形成环状链表，以及丢失数值的问题

环状链表问题

举个栗子现在又 A->B->C的链表
就好比两个线程同时做transfer操作

在扩容之后，正常的情况下会是这样

之后我们来说闭环问题的产生

这里可以看到线程一持有了A，但是时间片用完了，所以这里线程二来进行移位

完成之后是这样的

此时线程一开始运行，现在还持有A，之后就对其进行了覆盖

这是首次完成之后的结果，

之后进行复制

此时就出现了环状链表