深入集合框架之HashMap源码剖析

  1. 简介
  2. 源码分析

HashMap是JAVA抽象出来存储键值对的集合，它的底层是哈希表，有哈希表就会有冲突，所以HashMap用单链表解决冲突，也就是拉链法。

HashMap是不安全的，在多线程的环境下可用ConcurrentHashMap，或者利用Collections工具类中的同步方法。

先不急于说明其他的，我们先来分析一下单链表的构造

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;//存放键值对的键
        V value;    //存放值
        Entry<K,V> next;//存放链表中下一节点的地址
        final int hash;  //存放hash值

        /**
         * 创建一个新的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;
        }
        //当key存在时，用新值替换旧值，返回旧值
        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();
            //如果两个的键和值都相等才会返回true
            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();
        }

        //当向HashMap中put键值对时，如果对应的键已经存在，则会调用此函数
        void recordAccess(HashMap<K,V> m) {
        }

        //当删除HashMap中的某个值时，会调用此函数
        void recordRemoval(HashMap<K,V> m) {
        }
    }

接着我们来看看几个比较重要的成员变量

　　　//默认的初始容量，注意到是2的幂
　　　static final int DEFAULT_INITIAL_CAPACITY = 16;
　　　//默认最大容量，2的30次方
　　　static final int MAXIMUM_CAPACITY = 1 << 30;
　　  //　默认的加载因子
　　  static final float DEFAULT_LOAD_FACTOR = 0.75f;
　   //存放单链表头结点的哈希数组
　　  transient Entry[] table;
　　 //实际存放的值
　　  transient int size;
　　 //HashMap的阈值，如果超出阈值，则需要扩容（加载因子*容量）
　　　int threshold;
　　 /*加载因子的实际大小加载因子是表示Hash表中元素的填满的程度
　　   加载因子越大，填满的元素越多，好处是空间利用率高了，但冲突大了，链表很长，查找效率低;加载因子越小，填满的元素就越小，冲突小了，但是空间却浪费了。一般不设置*/
　　　final float loadFactor;
　　　//HashMap被修改的次数
　　　transient volatile int modCount;

这里提到了HashMap的容量是2的幂，当然还有数组的长度也必须为2的幂，稍后我们会说明这一点。

接下来是构造函数，HashMap一共有四个构造函数，我们来逐一分析：

 public HashMap(int initialCapacity, float loadFactor) {
        //容量小于0会抛出异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        //如果初始化的容量大于默认的最大容量，则用其替换
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //加载因子小于0，或者是一个NaN会抛出异常
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        //找到大于指定容量的最小的2次幂
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        //边界等于容量*加载因子
        threshold = (int)(capacity * loadFactor);
        //初始化哈希数组
        table = new Entry[capacity];
        init();
    }

//如果单独指定容量，会调用上面那个构造函数
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
//给成员变量赋值，都是默认的初始值
  public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }
//参数是map，需要将m中的所有元素拷贝到HashMap中
public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        putAllForCreate(m);
    }

计算hash值和数组的索引位置

    //计算哈希值的方法，JDK这么做一定有其理由
  static int hash(int h) {
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
  static int indexFor(int h, int length) {
        return h & (length-1);
    }

我们来分析一下这个 h & (length-1) 的用意

这个写法很巧妙，保证了计算出来的索引不会大于数组的长度，另一方面也回答了我们最开始的那个疑惑：为什么数组的长度要设置为2的次方，因为如果是2的次方，h&（length-1）就相当于对length取模，这也保证了散列的均匀；另外如果是2的次方，说明了length末位是偶数，那么减一就是奇数，h奇数偶数都有可能，所以这样使得h&（length-1）每种可能都会出现，相反如果length-1是偶数的话，无论h是什么值，最后一位总会是0，那么取模后浪费一半的空间。

接下来我们分析HashMap中最重要的put和get方法

 public V put(K key, V value) {
         //若key为null，直接调用putForNullKey方法
        if (key == null)
            return putForNullKey(value);
         //计算哈希值
        int hash = hash(key.hashCode());
        //确定在数组中的索引位置
        int i = indexFor(hash, table.length);
        //从索引位置处，开始遍历单链表，当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;
            }
        }
        //对hashMap的修改次数加1，这个的作用我们稍后就会看到
        modCount++;
        //添加到单链表中
        addEntry(hash, key, value, i);
        return null;
    }

    //key为null的情况，我们发现当put的值为null时，会将其放置在哈希数组的第一个元素
  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;
    }
 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);
    }

接下来是分析get方法

public V get(Object key) {
        //类似get，当key为null时，我们调用getForNullKey方法
        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;
        }
        //没找到会返回null
        return null;
    }
    //当key为null时，我们只需要在数组的第一个元素后面的单链表搜索即可
   private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }
  • 关于扩容resize

从put方法我们可以看出，传递给resize的方法是2倍的哈希数组的长度

void resize(int newCapacity) {
        //首先确定容量是否达到了最大值，如果达到了最大值，则直接返回不在扩容
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        //生成一个新的数组，容量是原来的2倍
        Entry[] newTable = new Entry[newCapacity];
        //将原来数组中的值拷贝到扩容后的数组中
        transfer(newTable);
        //将新的哈希数组的首地址赋给原有的数组
        table = newTable;
        //重新计算边界
        threshold = (int)(newCapacity * loadFactor);
    }
 void transfer(Entry[] newTable) {
         //这里进行的是将原数组拷贝到先由数组中
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    //重新计算索引，因为数组长度变了
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

总结：

HashMap的put方法是传入需要put的键值对，首先判断键是否为null

如果为null：则直接在哈希数组首位元素的单链表中搜索，如果键为null的存在，则用新值替换旧值，否则直接插入。

如果不为null：则计算键的hash值，然后根据哈希值和数组长度计算要插入的索引，然后在单链表中判断是否存在，如果存在替换旧值，不存在插入新值

要注意的是，插入的时候，都是头插（在头结点之前插入）

HashMap的get方法类似put，这里不再解释

关于扩容，我们发现扩大的容量是原来数组的两倍，然后有要重新计算索引位置，接着是复制数组。这是非常耗性能的，所以在使用HashMap时，最好能提前给出大概的一个容量，提高HashMap的性能


HashMap有keySet，values，entrySet方法，分别返回HashMap中所有键的组合，所有值的组合，所有键值对的组合。

我们现在来分析一下这些的源码是如何实现的

首先来看看keySet

  public Set<K> keySet() {
          //keySet是AbstractMap中的成员变量，默认为null
        Set<K> ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }

//内部类实现KeySet，并重写部分方法
private final class KeySet extends AbstractSet<K> {
        public Iterator<K> iterator() {
            return newKeyIterator();
        }
        public int size() {
            return size;
        }
        public boolean contains(Object o) {
            return containsKey(o);
        }
        public boolean remove(Object o) {
            return HashMap.this.removeEntryForKey(o) != null;
        }
        public void clear() {
            HashMap.this.clear();
        }
    }
//我们来关注一下Iterator方法
 Iterator<K> newKeyIterator()   {
         //返回一个key的迭代器
        return new KeyIterator();
    }
  private final class KeyIterator extends HashIterator<K> {
        //重写Iterator中的next()方法
        public K next() {
            /*
             * 这里的nextEntry()是HashIterator中定义的方法
             * nextEntry返回一个链表的下一个节点，然后调用getKey获取键
             */
            return nextEntry().getKey();
        }
    }
/**
 *   自定义的HashIterator类，因为没有实现Iterator中的next方法，所以是抽象类
 */
 private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K,V> next;    // 下一个节点
        int expectedModCount;   // 提供fast-fail机制
        int index;      // 当前的索引
        Entry<K,V> current; // 当前的节点

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
                //找到数组中第一个不为null的节点
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }
        //判断后续是否还有节点
        public final boolean hasNext() {
            return next != null;
        }
        //下一个节点
        final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();
            //如果下一个节点不为空，就将下一个节点赋给next
            //否则在数组中找到下一个不为null的元素，即下一条链表
            if ((next = e.next) == null) {
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        current = e;
            return e;
        }
        //删除元素
        public void remove() {
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            //删除元素，类似单链表删除头结点
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }

    }

ps：疑问来了，在这里面定义的迭代器有什么用，类都是私有的？

比如我们输出的时候是new HashMap().keySet()，输出的时候，会自动调用父类（AbstractCollection）重写的toString方法，该方法会自动调用迭代器。

在HashIterator类中，我们看到了大量的比较modCount 和expectedModCount是否相等的语句，不知道各位是否还记得前面提出的一个问题，modCount有什么用？

modCount是volatile的，所以是对所有线程可见的（Volatile之所以是线程安全的，是因为保存的变量不保存缓存，都是直接在内存中的，所以可以保证线程之间的可见性）。

因为HashMap不是线程安全的，所以当一个线程在遍历HashMap的时候，另一个线程修改了HashMap，就会抛出ConcurrentModificationException异常。

所以这里我们用到了Fail-fast机制：

在最开始的时候，我们将modCount赋给expectedModCount，后面操作的时候，一旦发现这两个值不相等，就说明有线程修改了HashMap（导致modCount增加）

参考：

http://blog.csdn.net/ns_code/article/details/36034955

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-08 07:43:19

深入集合框架之HashMap源码剖析的相关文章

深入集合框架之Hashtable源码剖析

为了分析ConcurrentHashMap,决定先分析一下Hashtable,两者都是线程安全的,必然会有不同的区别,Hashtable和HashMap也有很大的区别. 我们先来看看Hashtable吧. 成员变量: //存储单链表表头的数组,和HashMap中类似 private transient Entry[] table; //Hashtable中实际元素的数量 private transient int count; //Hashtable的临界值(容量* 加载因子). private

深入集合框架之ArrayList源码剖析

ArrayList概述 ArrayList底层由数组实现,非线程安全,但是数组可以动态增加,也可以叫动态数组,提供了一系列的好处,我们来深入看看: 成员变量与构造函数 /** * 存储ArrayList内的数组 */ private transient Object[] elementData; /** * The size of the ArrayList (the number of elements it contains). * ArrayList中包含了多少元素 */ private

深入集合框架之HashSet源码剖析

HashSet实现了Set接口,也就是说它存储的元素是无重复的. 通过源码分析我们可以发现HashSet就是HashMap的一个实例. 因为在HashMap中的键是不能重复的,我们可以把HashSet想象成HashMap中的键,而且事实也就是如此. 接下来我们具体分析一个构造函数: 版权声明:本文为博主原创文章,未经博主允许不得转载.

深入集合框架之CopyOnWriteArrayList源码剖析

CopyOnWriteArrayList概述 CopyOnWriteArrayList是ArrayList的一个线程安全的变种. CopyOnWriteArrayList与ArrayList不同处就在于是否会拷贝数组和加锁. CopyOnWriteArrayList顾名思义就是写时复制的ArrayList,其意思就是在修改容器的元素时,并不是直接在原数组上修改,而是先拷贝了一份数组,然后在拷贝的数组上进行修改,修改完后将其引用赋值给原数组的引用.这样体现了读写分离,这样无论在任何时候我们都可以对

【Java集合源码剖析】HashMap源码剖析

转载请注明出处:http://blog.csdn.net/ns_code/article/details/36034955 HashMap简介 HashMap是基于哈希表实现的,每一个元素是一个key-value对,其内部通过单链表解决冲突问题,容量不足(超过了阀值)时,同样会自动增长. HashMap是非线程安全的,只是用于单线程环境下,多线程环境下可以采用concurrent并发包下的concurrentHashMap. HashMap 实现了Serializable接口,因此它支持序列化,

转：【Java集合源码剖析】HashMap源码剖析

转载请注明出处:http://blog.csdn.net/ns_code/article/details/36034955   您好,我正在参加CSDN博文大赛,如果您喜欢我的文章,希望您能帮我投一票,谢谢! 投票地址:http://vote.blog.csdn.net/Article/Details?articleid=35568011 HashMap简介 HashMap是基于哈希表实现的,每一个元素是一个key-value对,其内部通过单链表解决冲突问题,容量不足(超过了阀值)时,同样会自动

【Java集合源码剖析】HashMap源码剖析（转）

HashMap简介 HashMap是基于哈希表实现的,每一个元素是一个key-value对,其内部通过单链表解决冲突问题,容量不足(超过了阀值)时,同样会自动增长. HashMap是非线程安全的,只是用于单线程环境下,多线程环境下可以采用concurrent并发包下的concurrentHashMap. HashMap 实现了Serializable接口,因此它支持序列化,实现了Cloneable接口,能被克隆. HashMap源码剖析 HashMap的源码如下(加入了比较详细的注释): [ja

【源码】HashMap源码剖析

//----------------------------------------------------------------------------------- 转载需注明出处:http://blog.csdn.net/chdjj //----------------------------------------------------------------------------------- 注:以下源码基于jdk1.7.0_11 之前的几篇文章介绍了List集合中一些比较常见

Java HashSet和HashMap源码剖析

转自: Java HashSet和HashMap源码剖析 总体介绍 之所以把HashSet和HashMap放在一起讲解,是因为二者在Java里有着相同的实现,前者仅仅是对后者做了一层包装,也就是说HashSet里面有一个HashMap(适配器模式).因此本文将重点分析HashMap. HashMap实现了Map接口,允许放入null元素,除该类未实现同步外,其余跟Hashtable大致相同,跟TreeMap不同,该容器不保证元素顺序,根据需要该容器可能会对元素重新哈希,元素的顺序也会被重新打散,