HashMap1.7和1.8源码解读、流程分析、对比区别

HashMap原理

Jdk1.7:

数据结构

数组 + 链表

初始容量、加载因子

默认初始容量为16,加载因子为0.75

put数据流程

HashMap1.7和1.8源码解读、流程分析、对比区别_第1张图片

插入数据流程:

1.判断数组是否为空数组,如果为空则会去初始化数组

2.判断传入的key是否为null,如果为null,调用putForNullKey(value)方法,插入null数据

3.计算出传入key的hash值

4.通过hash值计算该key存入的下标位置(hashCode & (length-1))

5.遍历该下标位置的链表,判断传入key是否存在hash值相等并且key相等的元素

6.如果key相等,将新传入的value覆盖旧的value

7.如果key不相等,则在该位置插入(hash, key, value, i)

8.插入数据前先判断是否需要扩容,如果需要,则扩容,并将旧数组的元素移动到新数组

9.插入数数据,创建entry对象(createEntry(hash, key, value, bucketIndex)),插入链表头部

10.插入成功后size++

put源码
public V put(K key, V value) {
    if (table == EMPTY_TABLE) { // 判断数组是否为空数组,如果为空则会去初始化数组
        inflateTable(threshold);
    }
    if (key == null) // 判断传入的key是否为null,如果为null,调用putForNullKey(value)方法插入空数据
        return putForNullKey(value);
    int hash = hash(key); // 计算传入key的hash值
    int i = indexFor(hash, table.length); // 通过hash值计算该key存入的下标位置
    for (Entry<K,V> e = table[i]; e != null; e = e.next) { // 变量该下标位置的链表
        Object k;
     // 如果传入key的hash值与所在链表中数据的下标的hash值相等或者传入的key存在该链表中,将新的value替换旧的value,返回旧的value
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { 
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
  	// 添加数据(hash值,key,value,下标)
    addEntry(hash, key, value, i);
    return null;
}
inflateTable(threshold) :初始化数组方法(阈值)
private void inflateTable(int toSize) {
    // 找到一个大于等于toSize的2的n次方数
    int capacity = roundUpToPowerOf2(toSize);
  	// 阈值 = (容量 * 加载因子)不指定初始化容量和加载因子时,默认初始化容量为16,加载因子为0.75, MAXIMUM_CAPACITY为最大容量
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);
}
putForNullKey(value) :插入key为空的数据
private V putForNullKey(V value) {
  	// 遍历第0位下标的链表,插入数据,如果已存在数据,则替换
    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++;
  	// 插入数据(hash值为0,key为null,value,下标为0)
    addEntry(0, null, value, 0);
    return null;
}
indexFor(hash, table.length) :计算存储下标位置
static int indexFor(int h, int length) {
    // hash值 & (length - 1)
    return h & (length-1);
}

addEntry(hash, key, value, i) :添加数据

void addEntry(int hash, K key, V value, int bucketIndex) {
  	// 先判断是否需要扩容,当钱size > 阈值 且 当前要插入的下标位置不为空时
    if ((size >= threshold) && (null != table[bucketIndex])) {
      	// 调用扩容方法,直接将数组长度翻倍
        resize(2 * table.length);
      	// 扩容之后需要重新计算hash值,key为null的hash值为0
        hash = (null != key) ? hash(key) : 0;
      	// 重新计算存储下标位置
        bucketIndex = indexFor(hash, table.length);
    }
		// 创建对象存储(hash值,key,value,下标位置)
    createEntry(hash, key, value, bucketIndex);
}
resize(2 * table.length); 扩容方法
void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
  	// 判断原来数组是否为最大容量,如果是,则不再扩容, 默认最大容量是1 << 30
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
		// 扩容, 创建新的数组
    Entry[] newTable = new Entry[newCapacity];
  	// 将原来数组中的数据移动到新数组,并判断是否需要重新计算hash值
    transfer(newTable, initHashSeedAsNeeded(newCapacity));
    table = newTable;
  	// 更新阈值和最大容量
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
transfer(newTable, initHashSeedAsNeeded(newCapacity)); 将原来数组中的数据移动到新数组
void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
  	// 变量旧数组
    for (Entry<K,V> e : table) {
  			// 判断当前数据是否为null
        while(null != e) {
            Entry<K,V> next = e.next;
          	// 判断是否重新计算hash值,key为null时不需要计算
            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;
        }
    }
}
createEntry(hash, key, value, bucketIndex); 创建对象存储
void createEntry(int hash, K key, V value, int bucketIndex) {
  	// 获取原来当前下标位置数据,旧数据
    Entry<K,V> e = table[bucketIndex];
  	// 创建对象到该下标数组(hash值,key,value,旧数据)
    table[bucketIndex] = new Entry<>(hash, key, value, e);
  	// size统计
    size++;
}

Jdk1.8:

数据结构

数组 + 链表 + 红黑树

初始容量、加载因子、树化阈值、树退化阈值

初始容量16,加载因子0.75,树化阈值8,数退化阈值6

put数据流程

HashMap1.7和1.8源码解读、流程分析、对比区别_第2张图片

插入数据流程:

  1. 调用putVal插入数据,并计算key的hash值

  2. 判断数组是否为空或长度为0,如果为空调用resize方法初始化数组

  3. 根据hash & (length - 1) 计算下标位置,并判断当前下标是否为空

  4. 如果为空,则将新的数组添加至当前位置

  5. 如果不为空,判断下标节点的hash值和key是否与添加的节点是否相同

  6. 如果相等,新值覆盖旧值

  7. 如果不相等,判断添加的节点是否为树节点

  8. 如果是树节点,将添加的节点加入树中

  9. 如果不是树节点且key值不与下标key相等,遍历所在下标位置链表

  10. 判断当前链表是否下一个元素是否为null,如果为null,则在链表尾部插入数据

  11. 插入数据后,再判断当前链表大小是否大于树化阈值,如果是,就将链表树化

  12. 判断插入的数据与链表中的其它数据key相等,则覆盖旧值

  13. 插入数据后就跳出循环,返回旧值,再判断是否需要扩容,扩容后结束

put源码
public V put(K key, V value) {
		// 调用putVal方法(key的hash值,key,value。。。)
    return putVal(hash(key), key, value, false, true);
}
putVal(hash(key), key, value, false, true); 插入方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 数组是否为空,或者数组长度为0
    if ((tab = table) == null || (n = tab.length) == 0)
      	// 调用resize方法初始化数组
        n = (tab = resize()).length;
  	// 计算下标,判断下标位置的数据是否为空
    if ((p = tab[i = (n - 1) & hash]) == null)
      	// 如果为空,将新的数据加入该下标位置
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
      	// 判断下表节点的hash值是否与添加节点的hash值相等, 或者key是否相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
      	// 判断下标节点是否为树节点
        else if (p instanceof TreeNode)
          	// 将添加的节点加入树中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
          	// 遍历下标位置的链表
            for (int binCount = 0; ; ++binCount) {
              	// 判断当前节点是否有下一个节点
                if ((e = p.next) == null) {
                  	// 如果没有,就新建一个节点插入该链表尾部
                    p.next = newNode(hash, key, value, null);
                  	// 判断链表大小是否大于树化阈值,如果是,则将链表树化
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
              	// 判断链表中当前节点是否与新加节点的key相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
 				// 如果旧节点数据不为null,返回旧节点值
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
  	// 判断大小是否大于阈值,如果大于,扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}
treeifyBin(tab, hash); 树化
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
  	// 判断数组是否为空,或者数组大小是否小于最小容量,如果满足,则进行扩容,不树化
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
  	// 判断下标位置节点是否为null
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
          	// 转换成树节点
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
resize(); 扩容
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
  	// 旧数组长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
  	// 旧数组阈值
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
      	// 判断旧数组长度是否大于最大容量,则不进行扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
      	// 如果就数组大小左移1小于最大容量 且 大于等于默认初始化容量,则将旧数组阈值左移1
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}
HashMap1.7和1.8的区别
1. 数据结构不同:1.7是数组+链表,1.8是数组+链表+红黑树
2. 插入数据方法不同:1.7是使用的头插法,在链表头部插入数据,在多线程环境下,会产生环形链表问题,1.8是使用的尾插法,在链表尾部插入数据,当链表大小>=8,且容量>64,就将链表树化,不会产生环形链表问题
3. 初始化方法不同:1.7的infateTable()负责创建,1.8中,resize()在表为空时负责创建
4. 扩容和插入数据顺序不同:1.7先扩容,再插入数据,会颠倒链表顺序,1.8先插入数据,再扩容,不会颠倒链表顺序
5. hash值计算逻辑不同:1.7基于key的hashcode返回值又进行了一些位运算,1.8直接拿key的hashcode做高低位异或操作

你可能感兴趣的:(java,hashmap)