JDK1.7 HashMap源码分析

JDK1.7中HashMap采用的是数组+链表结构保存所有数据,其结构如下图:
JDK1.7之前HashMap结构
JDK1.8 HashMap源码分析中已经分析了JDk1.8中HashMap的结构更改,但是和JDk1.7之前的HashMap还是有很多共同点,下面我们着重分析不同点。

构造方法

构造方法主要完成出时容量和加载因子的设置,实现如下:

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

        this.loadFactor = loadFactor;
        threshold = initialCapacity;//初始阈值为初始容量,与JDK1.8中不同,JDK1.8中调用了tableSizeFor(initialCapacity)得到大于等于初始容量的一个最小的2的指数级别数,比如初始容量为12,那么threshold为16,;如果初始容量为5,那么初始容量为8
        init();//空实现
    }


 public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

 /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }


  public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        inflateTable(threshold);

        putAllForCreate(m);
    }

从上面可以看到,使用无参构造方法时,和JDK1.8的相同,默认的初始容量为16,默认的加载因子为0.75。但是在两个参数的构造方法时,实现稍有不同,关键是初始阈值的赋值。上面注释中已经说明了。

hash方法

JDK1.8中的hash方法如下:

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

而JDK1.7中的hash方法如下:

final int hash(Object k) {
        int h = hashSeed;//默认为0
        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);
    }

从上面可以看到JDk1.8中的hash方法实现简单得多。

基本操作

put方法

HashMap中的put(K k,V v)方法用于将一对键值对插入到哈希表中,返回的键对应的旧的值。实现如下:


static final Entry<?,?>[] EMPTY_TABLE = {};

    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

 public V put(K key, V value) {
        //哈希表还未被创建时,相同
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);//创建哈希表
        }

        //如果键是null,调用putForNullKey方法
        if (key == null)
            return putForNullKey(value);
        //计算hash值
        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;
    }

    //插入键为null的值
    private V putForNullKey(V value) {
        //可以看到键为null的值永远被放在哈希表的第一个桶中
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            //一旦找到键为null,替换旧值
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        //如果第一个桶中为null或没有节点的键为null的,插入新节点
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

从上面的代码可以看到put(K k,V v)有几步操作:
1. 如果哈希表还未创建,那么创建哈希表
2. 如果键为null,那么调用putForNullKey插入键为null的值
3. 如果键不为null,计算hash值并得到桶中的索引数,然后遍历桶中链表,一旦找到匹配的,那么替换旧值
4. 如果桶中链表为null或链表不为null但是没有找到匹配的,那么调用addEntry方法插入新节点

下面先分析当哈希表还未创建时调用的inflateTable()方法,其实现如下:

  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);//初始化hashSeed变量
    }

 private static int roundUpToPowerOf2(int number) {
        // assert number >= 0 : "number must be non-negative";
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }

从上面可以看到,初始化表是一个方法,其中也是根据初始容量得到不小于自己的最小的2的指数倍数的数,这个方法与1.8中tableSizeFor功能是一样的,所以初始化表时是相同的。
下面再分析addEntry()方法,其中第一个参数是hash值,第二个是键,第三个是值,第四个是哈希表中桶的索引。

void addEntry(int hash, K key, V value, int bucketIndex) {
        //如果尺寸已将超过了阈值并且桶中索引处不为null
        if ((size >= threshold) && (null != table[bucketIndex])) {
            //扩容2倍
            resize(2 * table.length);
            //重新计算哈希值
            hash = (null != key) ? hash(key) : 0;
            //重新得到桶索引
            bucketIndex = indexFor(hash, table.length);
        }

        //创建节点
        createEntry(hash, key, value, bucketIndex);
    }

 void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        //将该节点作为头节点
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        //尺寸+1
        size++;
    }

从上面可以看到新加的节点将是作为头节点加入到链表中的,这点是与JDk1.8中的区别。另外,1.7的扩容是插入之前之前判断,而1.8是插入之后再判断是否需要扩容,不过都是扩容2倍。下面再来看resize()方法的实现:

//扩容到新容量
 void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        //如果旧容量已经达到了最大,将阈值设置为最大值,与1.8相同
        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);
    }

//如果hashSeed变了,那么rehash为true,否则为false
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;
                //如果hashSeed变了,需要重新计算hash值
                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;
            }
        }
    }

从上面的代码可以看到resize()中需要完成对hashSeed变量的更新,一旦更新成功,那么就需要rehash,否则不需要。而将链表转换时,新表中的链表与原链表中的顺序将会颠倒。这儿可以看到与1.8中的区别,1.7中是通过控制hashSeed的变化导致hash()方法得到的hash值,而JDK1.8中一旦得到了一个键的hash值后,就不会再改变了,而是通过hash&cap==0为区分,将链表分散,而1.7是通过更新hashSeed将旧表中的链表分散。
至此,我们可以发现JDK1.7中很多与1.8的实现区别,如下:
1. JDK1.8中resize()方法在表为空时,创建表,在表不为空时,扩容;而JDK1.7中resize()方法负责扩容,inflateTable()负责创建表
2. 1.8中没有区分键为null的情况,而1.7版本中对于键为null的情况调用putForNullKey()方法。但是两个版本中如果键为null,那么调用hash()方法得到的都将是0,所以键为null的元素都始终位于哈希表中第一个桶中,这一点两个版本是相同的。
3. 当1.8中的桶中元素处于链表的情况,遍历的同时最后如果没有匹配的,直接将节点添加到链表了尾部,而1.7在遍历的同时没有添加数据,而是另外调用了addEntry()方法。
4. addEntry中默认将新加的节点作为链表的头节点,而1.8中会将新加的结点添加到链表末尾
5. 1.7中是通过更改hashSeed值修改节点的hash值从而达到rehash时的分散,而1.8中键的hash值不会改变,rehash时根据hash&cap==0将链表分散
6. 1.8rehash时保证原链表的顺序,而1.7中rehash时将改变链表的顺序

get方法

HashMap的get方法如下:

public V get(Object key) {
        //如果键为null,调用getForNullKey方法
        if (key == null)
            return getForNullKey();
        //键不为null,调用getEntry方法
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

private V getForNullKey() {
        if (size == 0) {
            return null;
        }
        //键为null的插入在第一个桶中
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

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

        //计算hash值
        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;
    }

从上面的代码可以看到,get()方法与1.8中差别不大,只是区分出了键是否为null的情况,而1.8中则不区分这种情况。

remove方法

remove()方法如下:

 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;
        }
        //计算hash值
        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;
    }

从remove()方法可以看到与1.8中的实现也差距不大。

总结

下面对JDK1.7和JDk1.8中HashMap的相同与不同点做出总结。
首先是相同点:
1. 默认初始容量都是16,默认加载因子都是0.75。容量必须是2的指数倍数
2. 扩容时都将容量增加1倍
3. 根据hash值得到桶的索引方法一样,都是i=hash&(cap-1)
4. 初始时表为空,都是懒加载,在插入第一个键值对时初始化
5. 键为null的hash值为0,都会放在哈希表的第一个桶中

接下来是不同点,主要是思想上的不同,不再纠结与实现的不同:
1. 最为重要的一点是,底层结构不一样,1.7是数组+链表,1.8则是数组+链表+红黑树结构
2. 主要区别是插入键值对的put方法的区别。1.8中会将节点插入到链表尾部,而1.7中会将节点作为链表的新的头节点
3. JDk1.8中一个键的hash是保持不变的,JDK1.7时resize()时有可能改变键的hahs值
4. rehash时1.8会保持原链表的顺序,而1.7会颠倒链表的顺序
5. JDK1.8是通过hash&cap==0将链表分散,而JDK1.7是通过更新hashSeed来修改hash值达到分散的目的

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 技术工厂 设计师:CSDN官方博客 返回首页