HashMap原理详解

最新推荐文章于 2020-09-29 15:12:13 发布

寻找那一盏灯

最新推荐文章于 2020-09-29 15:12:13 发布

阅读量230

点赞数

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

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

HashMap原理详解

本篇内容主要介绍一下HashMap中增删改查过程，版本为jdk7

HashMap的类继承关系
HashMap中的几个重要的成员变量
HashTable与查找key所在桶位置的几个方法
HashTable 与扩容有关的几个方法
HashMap中的存储的实体对象Entry
查找元素
添加映射
删除映射
后记

HashMap的类继承关系

这里写图片描述

HashMap中的几个重要的成员变量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//hashMap的最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认加载因子
*/
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;
/**
* hashmap中的映射数量.
*/
transient int size;
/**
* .阀值，当size超过这个值的时候，开始扩容，初始值为(capacity * load factor)
* @serial
*/
// 如果表== EMPTY_TABLE，那么这是在膨胀时将创建表的初始容量
int threshold;
/**
* 加载因子，用来生成阀值
* @serial
*/
final float loadFactor;
/**
* 统计hashmap的结构变化次数
*/
transient int modCount;
/**
* 用来作用于hashseed
*/
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
/**
* 与此实例关联的随机值，应用于密钥的哈希代码以使哈希碰撞难以找到。
* 如果是0，则*替代哈希被禁用。.
*/
transient int hashSeed = 0;

HashMap与查找key所在桶位置的几个方法

//用来对求key的hash值
final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

//根据hashtable的容量来重设hashseed值，从而更改hash值，从而使key尽可能的均匀分布在数组中，在扩容后调用
final boolean initHashSeedAsNeeded(int capacity) {
        boolean currentAltHashing = hashSeed != 0;
        boolean useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean switching = currentAltHashing ^ useAltHashing;
        if (switching) {
            hashSeed = useAltHashing
                ? sun.misc.Hashing.randomHashSeed(this)
                : 0;
        }
        return switching;
    }

//寻找映射在桶中的位置，h是key的hash值，length是数组的长度，通常length是2的幂，等效与h % length -1 
 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);
    }

HashTable 与扩容有关的几个方法

  /**
     * 初始化table
     */
    private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize
        int capacity = roundUpToPowerOf2(toSize);
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

    // table 扩容，当容量等于MAXIMUM_CAPACITY将不再扩容，触发扩容的条件为，(size >= threshold) && (null != table[bucketIndex]) bucketIndex为key的在数组中的位置
  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;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }
   /**
     * 将当前表中的所有条目转移到newTable.注意key的hash值有可能变化
     */
    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;
            }
        }
    }

HashMap中的存储的实体对象Entry

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;

        /**
         * Creates new entry.
         */
        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;
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

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

查找元素


public V get(Object key) {
        if (key == null)
            return getForNullKey();
        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;
    }

当key为null时直接去table[0]查找，否则计算key在table中的位置，并在对应的位置上查找，如果的对应的位置找不到，并且Entry的next属性不为null，则继续比对，如果都找不到则返回null

添加映射

// 比较映射是否存在，如果存在，则替换value值并返回旧的value值，否则调用addEntry
public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        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;
    }
    //添加元素
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);
        }

        createEntry(hash, key, value, bucketIndex);
    }
    //创建Entry对象，并添加到table中，注意每次添加元素，是直接放在链表的头部
    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

添加映射时，先查找key在表中的位置，如果对应的位值上查找是否有元素的key和请求的key相同，如果有，则替换之，并返回旧的数据，如果不存在，则判断是否需要扩容，如果需要扩容，且扩容的条件允许，则扩容，扩容的大小是原来的两倍，扩容后，根据输入的key，value构造Entry对象，并将原来位置上的Entry对象设置为新对象的next值，然后将新对象存放到对应的数组位置。

删除映射

public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

final Entry<K,V> removeEntryForKey(Object key) {
        if (size == 0) {
            return null;
        }
        int hash = (key == null) ? 0 : hash(key);
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                if (prev == e)
                    table[i] = next;
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }