Hashmap\LinkedHashMap的实现原理分析

虽然网上已有很多人写关于HashMap源码分析的文章,但看完过一段时间后,又有点模糊了,觉得只有自己真正再将其履一遍,并真正把它能讲清楚,自己才算真正掌握了。在读本文之前如果你对以下几个问题都了如指掌,此文可略过。
1. HashMap的数据结构是什么?hash冲突是指什么?
2. HashMap是怎么解决hash冲突的,链表法是如何实现的?
3. 为什么HashMap的容量必须是2的指数幂?
4. LinkedHashMap的实现与HashMap有哪些不同?LinkedHashMap是怎么实现元素有序的?
5. 为什么重写equals方法必须重写hashcode方法?
6. HashMap的put方法实现过程?

1. 数据结构

hashmap实际上是一个数组+链表的数据结构,hashmap底层是一个数组结构,数组中每一项又是一个链表结构。链表是为了解决hash冲突。

     /**
     * 空表
     */
    static final HashMapEntry<?,?>[] EMPTY_TABLE = {};

    /**
     * 内部是一个数组,数组的每一项是一个链表,数组的长度必须是2的指数幂,当需要时进行扩容
     */
    transient HashMapEntry<K,V>[] table = (HashMapEntry<K,V>[]) EMPTY_TABLE;
    /**
     * 数组的每一项是一个链表结构,通过next属性指向下一项,链表的每一项的是一个map结构数据,包含key、value
     */
    static class HashMapEntry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        HashMapEntry<K,V> next;
        int hash;
    }

2. hashmap的初始化

hashmap的构造函数中会对hashmap容量进行初始化,默认初始容量是16,装载因为为0.75,即当容量达到12时,会对hashmap进行扩容,增大一部,变成32.我们也可以调用其构造函数,自己设定其容量大小。

//initialCapacity初始容量,默认16、loadFactor装载因子,默认0.75
public HashMap(int initialCapacity, float loadFactor) {

 }

3. hasmap存取实现

3.1 put操作

put操作实现的方式是:根据key计算出hash值,查找在数组中对应的位置,判断该数组中对应位置是否有值,有值再判断是否有相同的key值,有则将新值替换旧值,并将旧值返回,存储结束。该数组在对应位置中没有值,或是有值但没有相同的key值,则新建一个Entry元素,并将其放到对应的数组位置处。
先看下源代码:

public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            //判断键是否为空,为空放到数组头部table[0]位置
            return putForNullKey(value);    
        //步骤1:通过hash算法计算出key的hash值
        int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);
        //步骤2:根据hash值找到其对应在hashmap数组中位置
        int i = indexFor(hash, table.length);
        //步骤3:查找hashmap的数组判断该位置是否有值,没有直接略过for循环,有则进入for循环中查找该位置对应的链表中元素的key值是否和当前要存储的元素的key值相同
        for (HashMapEntry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //如果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;
            }
        }

        modCount++;
        //步骤4:如果当前元素的hash值对应数组位置中链表不存在或是链表存在,但是链表中所有元素值的key与当前要存储的元素key值不一样的话,新建一个Entry保存到hashmap中
        addEntry(hash, key, value, i);
        return null;
    }

上述四个步骤并没有体现出hash冲突的处理方法,hash冲突是指key值不一样,但是计算出的hash值是一样的。我们接着看addEntry方法:

void addEntry(int hash, K key, V value, int bucketIndex) {
    //步骤1:检查当前hashmap中有值的数组是否达到极限值(默认初始容量16*0.75),若超过,会进行数组扩容。重新计算出当前要存入元素hash值对应在新数组中的位置
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? sun.misc.Hashing.singleWordWangJenkinsHash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    //步骤2:新建一个Entry对象存入hashmap中
    createEntry(hash, key, value, bucketIndex);
}

我们再进入createEntry函数查看hashmap是怎么将新元素存入数组中的。

void createEntry(int hash, K key, V value, int bucketIndex) {
    //步骤1:取出当前数组中的元素,是一个Entry链表结构数据
    HashMapEntry<K,V> e = table[bucketIndex];
    //步骤2:将当前元素加入到Entry中,将原值e和新值的key,value,hash传进去
    table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);
    size++;
}

在这里还没有体现出hashmap处理冲突的方式,我们接着看新建一个Entry元素方法。

HashMapEntry(int h, K k, V v, HashMapEntry<K,V> n) {
    value = v;//新值value
    next = n;//关键点,将旧值赋给新值的next,这样就相当于把新值放在链表头部,新元素的next指向原数组链表中的值
    key = k;
    hash = h;
}

终于找到了hashmap处理冲突的代码,当发生hash冲突时,会将新元素放在链表头部,并将next指向原链表中元素。打个比方, 第一个键值对A进来,通过计算其key的hash得到的index=2,记做:Entry[2] = A。一会后又进来一个键值对B,通过计算其index也等于2,HashMap会将B.next = A,Entry[2] = B,如果又进来C,index也等于2,那么C.next = B,Entry[2] = C;这样我们发现index=2的地方其实存取了A,B,C三个键值对,他们通过next这个属性链接在一起。

3.2 根据hash值查找在数组中位置

static int indexFor(int h, int length) {
        return h & (length-1);
    }

按位取并,作用上相当于取模mod或者取余%操作,但是利用二进制操作更快。这里就体现了为什么数组长度必须是2的指数幂,只有2的指数幂,比如16的二进制表示为 10000,那么length-1就是15,二进制为01111,同理扩容后的数组长度为32,二进制表示为100000,length-1为31,二进制表示为011111。而扩容后只有一位差异,也就是多出了最左位的1,这样在通过 h&(length-1)的时候,只要h对应的最左边的那一个差异位为0,就能保证得到的新的数组索引和老数组索引一致,大大减少了之前已经散列良好的老数组的数据位置重新调换.

3.3 存放key为空值实现

key值为空的所有元素都放到数组的头部table[0]位置处,这里会判断数组头部table[0]位置处是否有值,有值,再判断是否有相同的key值,有则替换,没有则新建一个Entry,步骤跟上面类似

private V putForNullKey(V value) {
        for (HashMapEntry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

4 get方法

get操作的源代码如下:

public V get(Object key) {
        //如果key值为null,则从数组头部中查找
        if (key == null)
            return getForNullKey();
        //根据元素的key值查找出对应的Entry
        Entry<K,V> entry = getEntry(key);
        //返回Entry对应的value值
        return null == entry ? null : entry.getValue();
    }

我们再看看getEntry()方法的实现

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

        //步骤一:计算出key对应的hash值
        int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
        //步骤二:查找hash值对应在数组中是否存在值,存在则判断对应Entry的key是否和要查找元素的key值相同,相同则返回对应的Entry
        for (HashMapEntry<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;
    }

5. hashmap遍历方法

1)采用Iterator遍历

    Iterator iter = map.entrySet().iterator();
  while (iter.hasNext()) {
      Map.Entry entry = (Map.Entry) iter.next();
      Object key = entry.getKey();
      Object val = entry.getValue();
  }

2)for each遍历

for (Entry<String, String> entry : map.entrySet()) {
    Object key = entry.getKey();
    Object val = entry.getValue();
}

6. LinkedHashMap原理

LinkedHashMap是HashMap的子类,实现结构和HashMap类似,只是HashMap中的链表是单向链表,而LinkedHashMap是双向链表,只是在在HashMap的基础上加上了排序实现。

6.1 构造函数

LinkedHashMap的构造函数较HashMap多了一个排序参数accessOrder。

/**
     * @param  initialCapacity 初始容量,16
     * @param  loadFactor      装载因子0.75
     * @param  accessOrder     排序方式标识,为true代表数组元素按照访问顺序排序,为false代表按照插入顺序排序,默认按插入顺序排序
     */
    public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

6.2 排序方式实现

在LinkedHashMapEntry中重写了recordAccess方法,在HashMap的HashMapEntry是个空方法。该方法判断是否按访问顺序进行排序,如果是调用addBefore()将当前被访问的元素移至链表头部。如果不是按访问顺序排序,则链表中元素没有变化。因为插入元素时,新插入的元素在HashMap中实现就是放到链表头部的。

void recordAccess(HashMap<K,V> m) {
            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
            if (lm.accessOrder) {
                lm.modCount++;
                remove();
                addBefore(lm.header);
            }
        }

/**
 * 将当前元素移至链表头部
 */
private void addBefore(LinkedHashMapEntry<K,V> existingEntry) {
            after  = existingEntry;
            before = existingEntry.before;
            before.after = this;
            after.before = this;
        }

6.3 put实现

LinkedHashMap没有对put方式进行重写,但对addEntry()、createEntry()和LinkedHashMapEntry中的recordAccess()方法进行了重写。因为在HashMap中put一个元素时,如果要存储的元素的hash值和key值在当前链表中存在的话,在替换旧值后,就调用了recordAccess()方法。而在createEntry()方法中,LinkedHashMap的实现如下,添加了addBefore()方法调用。将当前新插入的元素放至链表头部。

void createEntry(int hash, K key, V value, int bucketIndex) {
        HashMapEntry<K,V> old = table[bucketIndex];
        LinkedHashMapEntry<K,V> e = new LinkedHashMapEntry<>(hash, key, value, old);
        table[bucketIndex] = e;
        e.addBefore(header);//关键点,将当前元素放到链表头部,从而实现最近访问的元素都在链表头部
        size++;
    }

6.3 get实现

LinkedHashMap中,在进行获取元素时,也调用了recordAccess方法,将访问元素移至链表头部

public V get(Object key) {
        LinkedHashMapEntry<K,V> e = (LinkedHashMapEntry<K,V>)getEntry(key);
        if (e == null)
            return null;
        e.recordAccess(this);//关键点,如果是按访问顺序排序,会将当前访问的元素移至链表头部
        return e.value;
    }

7. LruCache中调用LinkedHashMap的实现

final LinkedHashMap<T, Y> cache = new LinkedHashMap<T, Y>(100, 0.75f, true);

通过设置accessOrder参数为true,就实现了按访问顺序排序。

8、为什么object类的equals()重写同时也要重写 hashcode ()?

Object对象的equals(Object)方法,对于任何非空引用值x和y,当且仅当x和y引用同一个对象时,此方法才返回true。
当equals()方法被重写时,通常必须重写hashcode()方法,hash协定声明相等对象必须具有相等的hashcode,如下:

1)当obj1.equals(obj2)为true时,obj1.hashCode()==obj2.hashCode()必须为true
2)当obj1.hashCode()==obj2.hashCode()为false时,obj1.equals(obj2)必须为false,若obj1.hashCode()==obj2.hashCode()为true时,obj1.equals(obj2)不一定为true.

若不重写equals,比较的将是对象的引用是否指向同一块内存地址,重写后目的是为了比较两个对象的value值是否相等。
Hashcode是用于散列数据快速存取,如利用HashSet\HashMap\Hashtable类来存储数据时,都是先进行hashcode值判断是否相同,不相同则没必要再进行equals比较。
如果重写了equeals()但没重写hashcode(),再new一个对象时,当原对象.equals(新对象)等于true时,两者的hashcode却不是一样的,由此会得出两个对象不相等的性况。在存储时,也会发生两个值一样的对象,hashcode不一样而存储两个,导致混淆。所以Object的equals()方法重写同时也要重写hashcode()方法。

经过自己撸一遍源码,自己再把它写下来,对HashMap实现的理解又加深了一点映象。

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值