hashmap的实现原理 数组 entry

HashMap在日常工作中使用场景非常多,程序员都知道是HashMap是线程非安全的,但是底层是以什么方式存储的?本人仔细研读了一下源码,也只是掌握了核心的存储功能,并没有把全部代码看明白,但是对于理解hashMap的存储结构完全够了。

存储结构

  1. hashmap底层是以数组方式进行存储。将key-value对作为数组中的一个元素进行存储。
  2. key-value都是Map.Entry中的属性。其中将key的值进行hash之后进行存储,即每一个key都是计算hash值,然后再存储。每一个Hash值对应一个数组下标,数组下标是根据hash值和数组长度计算得来。
  3. 由于不能的key有可能hash值相同,即该位置的数组中的元素出现两个,对于这种情况,hashmap采用链表形式进行存储。
  4. 下图描述了hashmap的存储结构图
    hashmap结构

Entry结构分析

  1. Entry是hashMap中封装key-value键值对的,主要包括如下属性
static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;// map中key值,可以为null。
        V value; // map中的value值,可以为null。
        Entry<K,V> next;// 链表引用,防止key值不同,hash值相同。
        int hash; // 每个key的hash值
        // 构造函数
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }
        // 同一个key时,新值替换旧值,返回旧值
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
       // key值重写equals方法
        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }
       // 重写hashCode值
        public final int hashCode() {
            return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
        }

        public final String toString() {
            return getKey() + "=" + getValue();
        }
      // 其他方法省略
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

HashMap属性分析

  1. HashMap的属性分析
public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
{

    /**
     *默认情况下,hashmap大小为16.即1<<4就是1乘以2的4次幂=16
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
      * hashMap的最大值
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 默认加载加载因子,即使用空间达到总空间的0.75时,需要扩容。
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 声明hashmap一个空数组。
     */
    static final Entry<?,?>[] EMPTY_TABLE = {};

    /**
     * 最开始时,hashmap是一个空数组。
     */
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

    /**
     * map的元素的个数
     */
    transient int size;

    /*
     * hashmap的实际存储空间大小。这个空间是总空间*加载因子得出的大小。
     * 比如默认是16,加载因子是0.74。则threshold就是12。
     */
    int threshold;

    /**
     * 加载因子,即使用空间达到总空间的0.75时,需要扩容。
     */
    final float loadFactor;

    /**
     *
     */
    transient int modCount;

    /**
     *  threshold这个值的最大值就是Integer.MAX_VALUE
     */
    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

put方法

  1. put(key,value)方法是hashmap中最重要的方法,使用hashmap最主要的就是使用put,get两个方法。put方法底层存储又是什么呢,我们可以从put方法的源码进行分析
 public V put(K key, V value) {
         // 首次存储元素,初始化存储空间
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        // 如果key为null,则将null放入元素的第一个位置
        if (key == null)
            return putForNullKey(value);
        // 计算key的hash值    
        int hash = hash(key);
        // 根据key的hash值,数组长度计算该Entry<key,value>的数组下标
        int i = indexFor(hash, table.length);
        /**
        **如果当前key的已经存在于map中,则将新值替换成旧值。
        **/
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 判断同一个key,既要判断hash值相同,还要判断key是同一个key,因为
            // 相同的key有可能hash值也相同。双重判断保证是同一个key。
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
       // 如果是新的key需要存储,则增加操作次数modCount++
        modCount++;
        // 将新增key-value键值对添加中map中。
        addEntry(hash, key, value, i);
        return null;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

addEntry方法

  1. addEntry方法是将新增的key-value键值对存入到map中。该方法主要完成两个功能:
    1.1. 添加新元素前, 判断是否需要对map的数组进行扩容,如果需要扩容,则扩容空间大小是多少?
    1.2. 对于新增key-value键值对,如果key的hash值相同,则构造单向列表。
  2. 从源码分析结果如下:
/**
**  hash:key的hash值
**  key:存储的键
**  value:存储的value对象值
*** bucketIndex:数组下标位置,即key-value在数组中的位置。
**/
void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
      // 往数组中添加新的key-value键值对
      createEntry(hash, key, value, bucketIndex);
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

createEntry

  1. 该方法主要完成两个功能,第一是添加新的key到Entry数组中,第二就是对于不同key的hash值相同的情况下,在同一个数组下标处,构建单向链表进行存储。
 void createEntry(int hash, K key, V value, int bucketIndex) {
       // 取出当前位置的元素,如果是新添加的key,则e为null,已经有的元素为不为空。
        Entry<K,V> e = table[bucketIndex];
        // 添加新的key-value值或构建链表
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
展开阅读全文

没有更多推荐了,返回首页