HashMap浅析

HashMap比较常用，但是具体是如何实现的，通过学习底层逻辑有了一定的了解，主要是由数组和链表实现，在这里针对HashMap做个浅析。
结构：

上图粗略的说明HashMap中的数组，而每个数组里边是一个链表即Entry，包括：key、value、next、hash。
几个主要参数：

1. threshold：阀值是表示达到该值时需要扩容；
2. loadFactor：扩容因子用于计划阀值，默认是0.75；
3. capacity：数组容量，始终是2^n。

put过程浅析

public V put(K key, V value) {
        //第一次时先初始化数组大小
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        //1、计算key的hash值
        int hash = hash(key);
        //2、找数组下标
        int i = indexFor(hash, table.length);
        //3、遍历指定数组数组下边位置的链表，是否有key值存在
        //若有则覆盖值，并返回旧值
        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++;
        //4、若不存在则添加到链表中
        addEntry(hash, key, value, i);
        return null;
    }

1、首先是table（实际上是一个Entry）为空时初始化数组大小inflateTable

private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize
        //1、对数组容量的大小进行处理保证是2^n
        int capacity = roundUpToPowerOf2(toSize);
        //2.计算阀值，capacity * loadFactor和MAXIMUM_CAPACITY + 1取小值
        //即capacity * loadFactor
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        //3、初始化
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

2、计算数组下标，就是hash值与数组大小的&运算，代码很简单

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

3、添加到链表中addEntry

void addEntry(int hash, K key, V value, int bucketIndex) {
        //1、数组已经达到扩容因子并且在数组下边中已存在数据，则进行扩容，并重新
        //计算hash值和数组下标
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        //2、将数据放到新的数组中，采用的是新的hash值和数组下标
        createEntry(hash, key, value, bucketIndex);
    }

添加到链表中的操作会对现有数组大小及查询数组下标位置是否有值，同时满足则会扩容并计算新的hash和数组下标，然后再放到新的数组中。
4、数组扩容resize，将当前数组长度*2

void resize(int newCapacity) {
        //1、将现有数组备份
        Entry[] oldTable = table;
        //2、现有数组大小备份
        int oldCapacity = oldTable.length;
        //判断是否达到最大值，若是最大值则直接返回
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        //3、定义新的数组，数组大小变为原来的2倍，
        Entry[] newTable = new Entry[newCapacity];
        //4、将数据迁移到新数组中，将当前数组指向新的数组并计算扩容因子
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

5、放到新数组中createEntry

void createEntry(int hash, K key, V value, int bucketIndex) {
        //1、获取数组下标位置
        Entry<K,V> e = table[bucketIndex];
        //2、创建实体对象存放，并将size++
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

创建实体链表new Entry，是将新值放到链表的表头。

get过程浅析

相比较put，get就比较简单了

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        //根据key获取值
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

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

构造方法

拿默认方式new HashMap()进行解析。

public HashMap() {
        //直接调用有参构造
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}

直接调用有参构造均采用默认值。

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +nitialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +loadFactor);
        //初始化扩容因子0.75
        this.loadFactor = loadFactor;
        //初始化阀值为默认数组大小DEFAULT_INITIAL_CAPACITY
        threshold = initialCapacity;
        init();
}

总结

• put操作主要有：
  1、初始化数组及阀值；
  2、计算hash值及数组下标；
  3、判断数组下标位置是否存在key，若存在则新值覆盖旧值并返回旧值；
  4、是否需要扩容，若扩容重新计算threshold阀值，hash值，新的数组下标；
  5、若不需要扩容且不存在key则在相应数组下标位置将数据放到链表的表头；
• get操作主要有：
  1、计算hash值及下标；
  2、找到数组下标位置，根据hash值和key遍历链表；