Java_从入门到JavaEE_18

最新推荐文章于 2024-09-13 21:40:38 发布

静风残云

最新推荐文章于 2024-09-13 21:40:38 发布

阅读量347

点赞数 8

文章标签： java java-ee 哈希算法

本文链接：https://blog.csdn.net/lv785/article/details/139010345

版权

HashMap底层源码解析以及相应问题的思考

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>{
	
    //默认初始化容量（必须是的2幂） - 16
    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 Entry<?,?>[] EMPTY_TABLE = {};
    
    //hash数组/hash表 - new Entry[16];
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
    //元素个数
    transient int size;//0
    //阈值
    int threshold;//12
    //负载因子
    final float loadFactor;//0.75f
    //外部操作数
    transient int modCount;//0
    //hash种子数
    transient int hashSeed = 0;//xxxx
    
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }
    
    //initialCapacity - 16
    //loadFactor - 0.75
    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))//NaN - Not a Number
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        this.loadFactor = loadFactor;
        threshold = initialCapacity;
        init();
    }
    
    //子类的初始化挂钩 -- 让LinkedHashMap重写
    void init() {
    }

    //key - new Student("王麻子", '男', 22, "2402", "003"), 
    //value - "写代码"
    public V put(K key, V value) {
        //第一次添加元素时进入的判断
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);//初始化工作
        }
        if (key == null)
            return putForNullKey(value);
        
        //获取key的hash值 --> hash - 20
        int hash = hash(key);
        //利用hash值计算在数组中的下标 --> i - 4
        int i = indexFor(hash, table.length);
        
        //注意：进入此循环就说明hash碰撞了
        //e - 0x004
        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))) {
                //oldValue - 看抖音
                V oldValue = e.value;
                e.value = value;//覆盖原有的value值
                e.recordAccess(this);
                return oldValue;//返回被替换的值
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }
    
    //h - 20
    //length - 16
    static int indexFor(int h, int length) {
        //0001,0100
        //0000,1111
        return h & (length-1);
    }
    
    //k - new Student("李四", '男', 21, "2402", "002")
    final int hash(Object k) {
        int h = hashSeed;
        
        //如果k是String类型，计算hash值就有hash种子数的参与
        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);
    }
    
   	//value - 抚琴
    private V putForNullKey(V value) {
        //注意：进入此循环就说明hash碰撞了
        //e - 0x001
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;//oldValue - 赏花
                e.value = value;//重新替换value
                e.recordAccess(this);
                return oldValue;//返回被替换的值
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }
    
    //hash - 20
    //key - new Student("王麻子", '男', 22, "2402", "003"), 
    //value - "看抖音"
    //bucketIndex - 4
    void addEntry(int hash, K key, V value, int bucketIndex) {
        //判断何时扩容
        if ((size >= threshold) && (null != table[bucketIndex])) {
            //扩容
            resize(2 * table.length);
            //重新计算hash值
            hash = (null != key) ? hash(key) : 0;
            //重新计算下标
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }
    
   	//newCapacity - 32
    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;//oldCapacity - 16
        
        //老的长度等于map的最大值，就将int的最大值赋值给阈值，意味减少不必要的扩容逻辑
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];//new Entry[32];
        
        //transfer() -> 1.重新计算hash种子数 2.将原有数组中的数据复制到新数组中
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        //将新数组的地址赋值给源数组
        table = newTable;
        //重新计算阈值 - threshold=24
        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;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }
    
    //hash - 20
    //key - new Student("王麻子", '男', 22, "2402", "003"), 
    //value - "看抖音"
    //bucketIndex - 4
    void createEntry(int hash, K key, V value, int bucketIndex) {
        
        //JDK1.7插入数据为头插法
        //e - 0x003
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }
    
    //toSize - 16
    private void inflateTable(int toSize) {
       
        //capacity - 16
        int capacity = roundUpToPowerOf2(toSize);

        //threshold - 12
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
       	//table = new Entry[16];
        table = new Entry[capacity];
        //根据容量生成hash种子数
        initHashSeedAsNeeded(capacity);
    }
    
    //number - 16
    private static int roundUpToPowerOf2(int number) {
        
        return number >= MAXIMUM_CAPACITY ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }
    
    //映射关系类/节点类
    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;// ------ 键
        V value;// ---------- 值
        Entry<K,V> next;// -- 下一个节点的地址
        int hash;// --------- key的hash值

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

HashMap<Student, String> map = new HashMap<>();
		
map.put(null, "赏花");//null
map.put(null, "抚琴");//赏花
map.put(new Student("张三", '男', 23, "2402", "001"), "踢足球");//null
map.put(new Student("李四", '男', 21, "2402", "002"), "看电影");//null
map.put(new Student("王麻子", '男', 22, "2402", "003"), "看抖音");//null
map.put(new Student("王麻子", '男', 22, "2402", "003"), "写代码");//看抖音