HashMap底层源码分析

1.集合关系和HashMap的特点

HashMap类底层继承AbstractMap，实现了Map<K,V>, Cloneable, Serializable接口
1. AbstractMap 抽象类实现了Map<K,V>接口
2. Map<K,V> 接口，定义了map集合的常用方法：增删改查等抽象方法
3. Cloneable接口，标记该对象可以克隆
4. Serializable接口，标记该对象可以实现序列化和反序列化
HashMap底层采用：数组 + 链表 + 树结构实现
1. 数组默认长度为16，加载因子为0.75，每次扩容都是2倍扩容；(加载因子-0.75 代表数据中元素个数达到当前长度的0.75倍之后数据开始就进行扩容)
2. 链表结构：同一个数组下标位置需要存储多个元素的时候，多个元素之间采用链表结构；HashMap底层采用单向的线性链表的形式
3. 树结构：单向链表结构，链表中的元素很多的时候，查询性能低，查询的深度深；降低查询的层级
HashMap 底层是由多个Entry节点对象组成（JDK1.6）/ 多个Node节点组成（1.8），entry[]数组是构成HashMap的核心数组

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
   }

2.构造方法

源码如下：

    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;
        this.threshold = tableSizeFor(initialCapacity);
    }

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

    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

HashMap共四个构造方法

3.put方法

源码如下所示：

transient int size; // 记录元素个数
int threshold;  // 记录阈值 0.75 * capacity
final float loadFactor;  //
    // 
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        // 定义成员变量 tab--底层数组结构 Node--节点  n--代表数组长度  i--代表下标            
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // (tab = table) == null--判断是否是第一次添加
        if ((tab = table) == null || (n = tab.length) == 0)
        // resize() 对数组扩容并进行初始化
            n = (tab = resize()).length;
        // p代表需要插入的节点    i = (n - 1) & hash -- i代表元素需要插入的下标,数组的最大下标 &最大值
        // p取值为tab[i] -- 先取出数组对应位置的元素，p == null证明数组中该下标位置没有元素
        if ((p = tab[i = (n - 1) & hash]) == null)
            // 
            tab[i] = newNode(hash, key, value, null);
        // 数组下标是由元素的   
        else {
            Node<K,V> e; K k;
            // 判断需要插入的元素是否和获取的元素重复，进行覆盖处理(e代表原始位置的元素,p代表新元素)
            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;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    // 覆盖原来的值   
                    p = e;
                }
            }
            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;
    }

HashMap添加元素的过程详解：
1. HashMap集合底层采用数组存储，数组的每个位置采用对应存储Entry的对象元素
2. 插入一个元素，首先计算插入元素的key值对应的hash值，得到存储到数组中的位置，然后查询该数组位置下是否有元素
3. 如果存在元素，调用equals方法判断该位置元素key值和插入元素key值是否相等，
  1. 如果相等替换元素的value值
  2. 如果不相等判断是否是树结构，如果是树结构，按照树结构的方式添加元素
  3. 判断是否是链表结构，从链表的第一个元素开始循环遍历，判断每一个元素是否相同（如果有相同则覆盖，如果没有继续遍历下一个；如果循环遍历还是不存在，则将元素添加到最后一位）
注意：
1. 新增元素的时候，需要判断链表结构是否需要转换为树结构；如果需要转换，则会转换为树结构之后再进行添加
2. 在添加元素的过程中，是怎么排序元素冲突：先判断hash值，在equals判断，
3. 最终添加完成元素之后，如果容量大于0.75乘以原始容量，进行数组扩容操作

4.数组扩容

扩容条件：数组默认初始容量为16，阈值为0.75 当集合中插入的元素个数达到容量*0.75 开始2
扩容方法及底层源码-- 扩容的方法是resize方法
数组扩容的主要属性

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 默认初始化容量 
static final int MAXIMUM_CAPACITY = 1 << 30; 最大容量 
static final float DEFAULT_LOAD_FACTOR = 0.75f; 默认加载因子-数组扩容的阈值，数组中的容量： 0.75 * 16 = 12 
static final int TREEIFY_THRESHOLD = 8; 转换为树结构的节点的个数

利用反射机制观察容量变化代码实现

package cn.mikeal.collection;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;

public class MapListTest {

	public static void main(String[] args) {
		HashMap<String, Integer> maps = new HashMap<>();
		for (int i = 0; i < 12; i++) {
			maps.put("zs" + i, 23);
		}
		System.out.println(maps.size());
		System.out.println(getCapacity(maps));

	}
	
	// 利用反射获取当前ArrayList集合的容量
	public static Object getCapacity(HashMap<String,Integer> maps) {
		Class<HashMap> clazz = HashMap.class;
		try {
			Field capacity = clazz.getDeclaredField("threshold");
			capacity.setAccessible(true);
			Object object = capacity.get(maps);
			return object;
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return -1;
		}
	}

}

HashMap底层源码分析

1.集合关系和HashMap的特点

2.构造方法

3.put方法

猜你喜欢