1.集合关系和HashMap的特点
- HashMap类底层继承AbstractMap,实现了Map<K,V>, Cloneable, Serializable接口
- AbstractMap 抽象类实现了Map<K,V>接口
- Map<K,V> 接口,定义了map集合的常用方法:增删改查等抽象方法
- Cloneable接口,标记该对象可以克隆
- Serializable接口,标记该对象可以实现序列化和反序列化
- HashMap底层采用:数组 + 链表 + 树结构 实现
- 数组默认长度为16,加载因子为0.75,每次扩容都是2倍扩容;(加载因子-0.75 代表数据中元素个数达到当前长度的0.75倍之后数据开始就进行扩容)
- 链表结构:同一个数组下标位置需要存储多个元素的时候,多个元素之间采用链表结构;HashMap底层采用单向的线性链表的形式
- 树结构:单向链表结构,链表中的元素很多的时候,查询性能低,查询的深度深;降低查询的层级
- 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添加元素的过程详解:
- HashMap集合底层采用数组存储,数组的每个位置采用对应存储Entry的对象元素
- 插入一个元素,首先计算插入元素的key值对应的hash值,得到存储到数组中的位置,然后查询该数组位置下是否有元素
- 如果存在元素,调用equals方法判断该位置元素key值和插入元素key值是否相等,
- 如果相等替换元素的value值
- 如果不相等判断是否是树结构,如果是树结构,按照树结构的方式添加元素
- 判断是否是链表结构,从链表的第一个元素开始循环遍历,判断每一个元素是否相同 (如果有相同则覆盖,如果没有继续遍历下一个;如果循环遍历还是不存在,则将元素添加到最后一位)
- 注意:
- 新增元素的时候,需要判断链表结构是否需要转换为树结构;如果需要转换,则会转换为树结构之后再进行添加
- 在添加元素的过程中,是怎么排序元素冲突: 先判断hash值,在equals判断,
- 最终添加完成元素之后,如果容量大于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; } } }