Java开发大牛用代码演示基于JDK1.6版本下的HashMap详解

Posted 2021-04-24 编程学习营

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java开发大牛用代码演示基于JDK1.6版本下的HashMap详解相关的知识，希望对你有一定的参考价值。

HashMap可以说是java从业者经常用到的，尽管网上有很多介绍HashMap的文章，但是我还是想写一写自己的一些见解，同时加深自己对HashMap的理解与印象。

首先，HashMap最早出现于jdk1.2，位于java.util包下。

HashMap继承了AbstractMap，实现了Map, Cloneable, Serializable。

这里咱们分两个版本进行介绍，分别是jdk1.6和jdk1.8。1.8在1.6的基础上有了很大的改进。

JDK1.6下的HashMap

整个类加上注释一共有代码1039行，整个类的变量一共十个。类方法40个。内部类一共8个。

咱们先看一个贯穿全文的内部类，是HashMap的基本组成。

那就是Entry。

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final 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 final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }

        public final String toString() {
            return getKey() + "=" + getValue();
        }

        /**
 * This method is invoked whenever the value in an entry is
 * overwritten by an invocation of put(k,v) for a key k that's already
 * in the HashMap.
 */
        void recordAccess(HashMap<K,V> m) {
        }

        /**
 * This method is invoked whenever the entry is
 * removed from the table.
 */
        void recordRemoval(HashMap<K,V> m) {
        }
    }

HashMap是由数组+链表构成，那么数组和链表就是一个个Entry组成。我们可以看到Entry类包含的变量有泛型的key，value，以及同是Entry类型的指针，hash值。

自己手画了一个HashMap的组成结构图。

十个类变量：

private static final long serialVersionUID = 362498820763181265L;

serialVersionUID基本是每个需要序列化的类都有的一个变量，不作介绍。

static final int DEFAULT_INITIAL_CAPACITY = 16;

DEFAULT_INITIAL_CAPACITY是table数组默认容量，默认为16。

static final int MAXIMUM_CAPACITY = 1 << 30;

MAXIMUM_CAPACITY是table数组最大容量，为2的30次方。

static final float DEFAULT_LOAD_FACTOR = 0.75f;

DEFAULT_LOAD_FACTOR：默认加载因子，初始值0.75。

transient Entry[] table;

table是HashMap的主要构成，数组里面放的是Entry类型的数据。

transient int size;

size是HashMap包含键值对的数目。

int threshold;

这个是table数组扩容的标准，达到这个值就会进行扩容，默认的值是。容量*加载因子。

final float loadFactor;

这个是hash表的加载因子。

transient volatile int modCount;

modCount记录HashMap被修改的次数。包括插入删除等操作。

private transient Set<Map.Entry<K,V>> entrySet = null;

entrySet 是存储Entry类型数据的set。

40个类方法就不一一介绍了。选几个相对重要的看看。

首先是默认构造方法

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

我们可以看到使用的是默认的容量和加载因子。对loadFactor、threshold赋值。以及初始化table。init()是一个空方法，不作讨论。

除了默认构造方法，还有其它三个构造方法。分别是HashMap(int initialCapacity)、HashMap(int initialCapacity, float loadFactor)、HashMap(Map<? extends K, ? extends V> m)。

HashMap(int initialCapacity)会调用HashMap(int initialCapacity, float loadFactor)，传入默认的加载因子。HashMap(Map<? extends K, ? extends V> m)则是根据传进来的map生成具有同样键值对的map。

这里我们看一下HashMap(int initialCapacity, float loadFactor)

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))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
        init();
    }

上面可以看到显示判断传入的初始容量和加载因子，如果不符合要求则抛出异常，超过最大容量则默认最大容量。capacity <<= 1;这个很有意思，一直循环找到大于你传进去初始容量的2的阶乘。这个也保证了table的大小为2的倍数。后面的代码也和前面说的一样了。

下面主要看一下核心的put和get方法。

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        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;
    }

首先判定key是否为空，为空调用putForNullKey(value)。这里说明了一个问题，那就是hashmap接受key为空的情况，同样value也可以为空。那么基本和hashmap没什么区别的hashtable，却不允许空value的情况，会抛出空指针异常。

我们先假设key为空，看一下putForNullKey(value)。

 private V putForNullKey(V value) {
        for (Entry<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;
    }

默认取table数组index为0的位置的链表，如果发现有key为空的情况，则替换value。如果遍历完之后都没有匹配的。就modCount自增，调用 addEntry方法。

void addEntry(int hash, K key, V value, int bucketIndex) {
	Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }

通过上面代码我们可以看到这个时候就是把空的key，value封装成Entry放到table[0]的位置，同时插入链表。这里也判断如果插入之后大小超过扩容大小（threshold），则调用resize方法扩容。

resize方法就不贴源码了，再贴就有点深了，一会儿收不回来。简单说一下resize做了什么事情。resize主要new了一个传进去的数值大小的Entry数组，然后把之前table的Entry转移到新的Entry数组中，这个过程中根据每个Entry的hash值，重新定位了在新数组中的位置，然后将原table指针指向新的Entry数组，完成扩容。

然后咱们再回到最开始的put方法。这里重新贴一下代码。

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        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;
    }

key不为空，对key的hashcode值进行一次hash运算，然后根据得到的hash值，调用indexFor方法得到在table数组中的位置，接着遍历table数组位置上的链表，如果存在相同的key，则对value值进行覆盖。否则在该table链表头部插入该键值对。我们刚才看过addEntry方法，里面会自增size，然后判断是否大于threshold（扩容临界值），如果是调用resize方法，这样说明什么呢？

举个例子。一个默认大小16的HashMap，如果里面存放了11个值，但是只占据了10个数组单元空间，其中一个链表上有两个键值对。只需要再放入一个键值对，不管在之前10个链表下，还是新占据一个单元空间，HashMap都会扩容。并不是占据16个数组单元中的12个。这样做我想到的好处是扩容后，调用indexFor方法，所有键值对会分布更加均匀，保证每个链表只有一个元素。

看代码的时候，我就在想如果不扩容，HashMap也能存下非常多的元素，为什么还要扩容呢？答案是便于操作，如插入和查找。一次hash和indexFor方法就能找到，为什么还要遍历长长的链表去找呢？

接着看一下get方法，看了put之后再看这个就很简单了。

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        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.equals(k)))
                return e.value;
        }
        return null;
    }

首先同样是key为空的情况，调用getForNullKey()。

private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

put key为空时我们直接放在table[0]的链表里，所以这里直接遍历0处的链表，找到直接返回，否则返回null。

不为空时就调用hash，indexFor方法，遍历对应位置上的链表，返回相应的值。

接下来看一下remove方法。

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

直接调用removeEntryForKey方法。

final Entry<K,V> removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        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;
    }

这个方法定位到所删除元素所属链表的数组位置，然后new了两个Entry类型的指针，prev和e。两个指针同时遍历链表，这个就是链表删除常用的操作，当e遍历到所删除元素所在节点，prev指针在e的前一个节点，只需要prev指针的next指向e的next，那么就把e所在的节点从链表中删除了。

源码的部分就到这里结束了。下面是对HashMap的一些扩展。

HashMap遍历,这里使用了entrySet，调用Set的iterator方法。

Map<String,Object> map = new HashMap<String,Object>();
Iterator iterator=map.entrySet().iterator();
while(iterator.hasNext()){
      Map.Entry entry=(Map.Entry)iterator.next();
      System.out.println(entry.getKey()+"\t"+entry.getValue());
}

在开始的时候，说了HashMap继承了AbstractMap，实现了Map。但是同时AbstractMap也实现了Map，那么AbstractMap也实现了Map的所有方法，这里为什么还要实现Map呢？

一开始觉得是多余了，因为已经继承AbstractMap了。后来网上搜了一下确实是多余了。作者Josh Bloch 自己承认当时没考虑到这点，还以为实现Map有点价值。不过这个也一直这样保留了，也没有更改。

本来想把1.8的介绍和1.6写在一起，但是1.8 HashMap的东西也不少，整合一起感觉篇幅太长，还是决定分开写。感兴趣的可以在专栏看另外一篇1.8的介绍。后续几天会发出来。以后有新的关于HashMap的理解也会更新在这里。