集合源码分析
程序=数据结构+算法
了解清楚数据结构和算法有助于理解我们经常调用的api底层是如何进行操作的
集合概述
集合是存储数据的容器，常用的集合分Collection和Map两个接口大类，如下图所示：
ArrayList详解
类图结构
首先我们来看下ArrayList的类图结构
源码分析
声明的属性
| 属性类型 | 属性名 | 作用 |
|---|---|---|
| int | DEFAULT_CAPACITY | 默认的数组容量：10 |
| Object[] | EMPTY_ELEMENTDATA | 用于共享的空实例数组 |
| Object[] | DEFAULTCAPACITY_EMPTY_ELEMENTDATA | 空的实例数组 |
| Object[] | elementData | ArrayList中实际存储数据的容器，其实是一个数组 |
| int | size | 记录集合中元素的个数 |
构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public ArrayList(Collection<? extends E> c) {
// 将传递的集合转换为数组 然后赋值给了 elementData
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
比较简单，默认ArrayList的初始值是10，可指定对应的初始化大小，当构造方法中传入一个集合的时候会将集合转换为数组，然后赋值给实际存储的elementData中
添加操作
| 方法名 | 描述 |
|---|---|
| public boolean add(E e) | 将指定的元素追加到此列表的末尾 |
| public void add(int index, E element) | 在此列表中的指定位置插入指定的元素 |
| public boolean addAll(Collection<?> c ) | 顺序的添加指定集合中的元素到当前集合末尾 |
| public boolean addAll(int index,Collection<? extends E>c) | 将指定集合的元素添加到当前集合对应的位置 |
add（E e）
public boolean add(E e) {
// 校验内部容量
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
// calculateCapacity计算容量
// ensureExplicitCapacity 继续校验
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
calculateCapacity方法
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 判断集合存数据的数组是否等于空容量的数组
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 通过最小容量和默认容量 求出较大值 (用于第一次扩容)
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
ensureExplicitCapacity方法
private void ensureExplicitCapacity(int minCapacity) {
//实际修改集合次数++ (在扩容的过程中没用,主要是用于迭代器中)
modCount++;
//判断最小容量 - 数组长度是否大于 0
if (minCapacity - elementData.length > 0)
//将第一次计算出来的容量传递给 核心扩容方法
grow(minCapacity);
}
grow方法
private void grow(int minCapacity) {
//记录数组的实际长度,此时由于木有存储元素,长度为0
int oldCapacity = elementData.length;
//核心扩容算法 原容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
//判断新容量 - 最小容量 是否小于 0, 如果是第一次调用add方法必然小于
if (newCapacity - minCapacity < 0)
//还是将最小容量赋值给新容量
newCapacity = minCapacity;
//判断新容量-最大数组大小 是否>0,如果条件满足就计算出一个超大容量
if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity);
// 调用数组工具类方法,创建一个新数组,将新数组的地址赋值给
elementData = Arrays.copyOf(elementData, newCapacity);
}
总结：ArrayList是采取懒加载扩容的方式，也就是说在初始化ArrayList的时候只会给他开辟一个空的数组，在第一次添加元素的时候会扩容一次（开辟初始值为10的数组并赋值给elementData），后续当元素个数大于数组长度的时候才会进行扩容处理。
在ArrayList调用add方法的操作
- 先进行容器容量的计算，若为空数组则取默认最小扩容值10，否则取添加后的容量大小
- 将最小容量和当前数组中的长度进行比较，若大于则进行扩容操作
- 计算出新的容量（旧容量+旧>>1,也就是原容量的1.5倍）
- 比较新容量是否小于最小容量，若小于则新容量为最小容量（这种情况针对第一次调用add，初始化容量为10）
- 比较当前新容量是否大于最大数组大小，若大于则变为Interger.maxValue(某些 VM 会在数组中保留一些标头词。尝试分配更大的数组可能会导致，所以默认的是Interger.maxValue-8的大小)
- 创建新的数组并将地址赋值给将实际存储数据的数组变量elementData
add(int index,E element)
public void add(int index, E element) {
// 检查index的合法性
rangeCheckForAdd(index);
// 校验内部容量
ensureCapacityInternal(size + 1); // Increments modCount!!
// index = 3
// [1,2,3,4,5] --> [1,2,3, ,4,5]
// 将 elementData index=3后的元素复制到 elementData 的 index+1=4后的位置
// 也就是空出来了 index 的位置
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
addAll(Collection<?> c )
public boolean addAll(Collection<? extends E> c) {
//把集合的元素转存到Object类型的数组中
Object[] a = c.toArray();
//记录数组的长度
int numNew = a.length;
//调用方法检验是否要扩容,且让增量++
ensureCapacityInternal(size + numNew); // Increments modCount
//调用方法将a数组的元素拷贝到elementData数组中
System.arraycopy(a, 0, elementData, size, numNew);
//集合的长度+=a数组的长度
size += numNew;
//只要a数组的长度不等于0,即说明添加成功
return numNew != 0;
}
addAll(i nt index,Collection<? extends E> c)
public boolean addAll(int index, Collection<? extends E> c) {
// 校验index是否合法
rangeCheckForAdd(index);
// 传递进来的集合转换为数组
Object[] a = c.toArray();
// 记录数组的长度
int numNew = a.length;
// 校验是否要扩容
ensureCapacityInternal(size + numNew); // Increments modCount
// 计算 数组要插入到 集合的index 下标
int numMoved = size - index;
if (numMoved > 0)
// 调整 elementData 中的数据的位置 给新插入的数据流出空间
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
// 将数据中的数据插入到新的数组对应的位置中即可
System.arraycopy(a, 0, elementData, index, numNew);
// 集合容量增加
size += numNew;
return numNew != 0;
}
总结：添加元素到指定位置主要会进行以下3个步骤：
- 检查index合法性（index>size && index<0）
- 校验内部容量（具体内容见add方法）
- 拷贝指定索引后面的数据，挪到后面，空出指定index位置（指定范围）
- 添加数据到指定的索引index上（指定范围）
注意：
方法：addAll(i nt index,Collection<? extends E> c)
其中元素不会覆盖，例：list1 -【1，2，7，8】list2 -【3,4,5】
调用list1.addAll(2，list2)
则list1变为【1，2，3，4，5，7，8】
Vector详解
类图结构
和ArrayList的区别
本质上和ArrayList上没有区别，只是在添加方法上添加了synchronized，所以Vecotor是数据安全的
HashSet详解
类图结构
HashSet的本质
从上图看，HashSet本质就是HashMap，所以我们搞懂了HashMap就可以了，HashMap后面重点讲解。
TreeSet详解
类图结构
TreeSet的本质
如上图所示，TreeSet的本质其实就是TreeMap，和HashSet一样，只要搞清楚对应的TreeMap即可。
TreeMap详解
类图结构
源码分析
TreeMap本质就是一个红黑树，所以我们需要理解红黑树的增加、删除的过程，在看源码就比较简单了。
成员变量
// 用于维护此树状图中顺序的比较器，如果使用其键的自然顺序，则为 null。
private final Comparator<? super K> comparator;
// 根节点 Entry 相当于之前的 RBNode 类型
private transient Entry<K,V> root;
/**
* 树中的条目数
*/
private transient int size = 0;
/**
* 对树进行结构修改的次数
*/
private transient int modCount = 0;
Entry的具体声明
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;
V value;
Entry<K,V> left;
Entry<K,V> right;
Entry<K,V> parent;
boolean color = BLACK;
}
公共方法
leftRotate(Entry e)方法
/**
* 围绕p左旋
* p pr(r)
* / | / \
* pl pr(r) => p rr
* / \ / \
* rl rr pl rl
* 该过程主要分为三个阶段的逻辑
* 1.左旋的时候最叶子节点变动
* 2.最外层父节点的节点变动
* 3.最高层及节点变动
*/
public void leftRotate(RBNode p) {
if (p != null) {
//获取右节点
RBNode r = p.right;
// 1.rl设置到p的右节点
p.right = r.left;
if (r.left != null) {
r.left.parent = p;
}
// 2.判断p的父节点情况
// 不管p是否有父节点，都要它的父节点设置为r的父节点
r.parent = p.parent;
// p没有父节点则r是父节点,若p为父节点的左节点则r为父节点的右节点（反之则反）
if (p.parent == null) {
root = r;
} else if (p.parent.left == p) {
p.parent.right = r;
} else {
p.parent.left = r;
}
// 3.设置p为r的左子节点
r.left = p;
p.parent = r;
}
}
rightRotate(Entry e)
/**
* p pl
* / \ / \
* pl pr ==> ll p
* / \ / \
* ll lr lr pr
* <p>
* 右旋和左旋一样，left置为right即可镜像操作
*
*/
public void rightRotate(RBNode p) {
if (p != null) {
// 1.右旋叶子结点操作
RBNode pl = p.left;
p.left = pl.right;
if (pl.right != null) {
pl.right.parent = p;
}
// 2.父节点外节点的操作
pl.parent = p.parent;
if (p.parent == null) {
root = pl;
} else if (p.parent.left == p) {
p.parent.left = pl;
} else {
p.parent.right = pl;
}
// 3.父节点子节点的操作
pl.right = p;
p.parent = pl;
}
}
put方法
public V put(K key, V value) {
// 1.查找插入的位置
Entry<K,V> t = root;
// 第一次插入 插入的节点设置为 root 节点
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1; // 记录集合中的元素个数
modCount++; // 记录操作的次数
return null;
}
int cmp; // 比较的值
Entry<K,V> parent; // 记录插入节点的父节点
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) { // 比较器不为空
// 遍历找到插入的位置
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
// 插入的值在容器中有相同的值 直接覆盖
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
// 比较器为空就创建一个比较器
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
// 找到插入的位置
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
// 需要插入的 k v 对封装为 Entry对象
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
// 变色和调整操作
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
fixAfterInsertion(e)方法
private void fixAfterInsertion(Entry<K,V> x) {
// 插入节点 默认就是红色节点
x.color = RED;
// 只有 插入节点的 父节点是 黑色节点才需要 调整平衡
while (x != null && x != root && x.parent.color == RED) {
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
// 插入节点的 父亲节点是 爷爷节点的左节点
// 获取叔叔节点
Entry<K,V> y = rightOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
// 存在叔叔节点
// 父亲和叔叔节点 变为黑色
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
// 爷爷节点变为红色
setColor(parentOf(parentOf(x)), RED);
// 将插入节点调整为 爷爷节点 然后递归处理
x = parentOf(parentOf(x));
} else {
// 没有叔叔节点
if (x == rightOf(parentOf(x))) {
// 插入节点是父节点的右子节点 需要先根据父亲节点左旋一次
// 6 6
// / /
// 4 ==> 5
// \ /
// 5 4
x = parentOf(x);
rotateLeft(x);
}
// 然后父亲节点设置为 黑色 爷爷节点设置为红色
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
// 右旋一次即可
rotateRight(parentOf(parentOf(x)));
}
} else {
// 和上面的情况刚好相反
Entry<K,V> y = leftOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == leftOf(parentOf(x))) {
x = parentOf(x);
rotateRight(x);
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));
}
}
}
// 将 root 节点设置为 黑色节点
root.color = BLACK;
}
remove方法
public V remove(K key) {
RBNode node = getNode(key);
if (node == null) {
return null;
}
V oldValue = (V) node.value;
deleteNode(node);
return oldValue;
}
getNode方法
private RBNode getNode(K key) {
RBNode node = this.root;
while (node != null) {
int cmp = key.compareTo((K) node.key);
if (cmp < 0) {
node = node.left;
} else if (cmp > 0) {
node = node.right;
} else {
return node;
}
}
return null;
}
deleteNode方法
/**
* 删除节点
* 3种情况
* 1.删除叶子节点，直接删除
* 2.删除的节点有一个子节点，那么用子节点来替代
* 3.如果删除的节点右两个子节点，此时需要找到前驱节点或者后继节点来替代
* 可以转换为 1、2的情况
* @param node
*/
private void deleteNode(RBNode node){
// 3.node节点有两个子节点
if(node.left !=null && node.right != null){
// 找到要删除节点的后继节点
RBNode successor = successor(node);
// 然后用后继节点的信息覆盖掉 要删除节点的信息
node.key = successor.key;
node.value = successor.value;
// 然后我们要删除的节点就变为了 后继节点
node = successor;
}
// 2.删除有一个子节点的情况
RBNode replacement = node.left != null ? node.left : node.right;
if(replacement != null){
// 替代者的父指针指向原来 node 的父节点
replacement.parent = node.parent;
if(node.parent == null){
// 说明 node 是root节点
root = replacement;
}else if(node == node.parent.left){
// 双向绑定
node.parent.left = replacement;
}else{
node.parent.right = replacement;
}
// 将node的左右孩子指针和父指针都指向null node等待GC
node.left = node.right = node.parent = null;
// 替换完成后需要调整平衡
if(node.color == BLACK){
fixAfterRemove(replacement)
}
}else if(node.parent == null){
// 说明要删除的是root节点
root = null;
}else{
// 1. node节点是叶子节点 replacement为null
// 先调整
if(node.color == BLACK){
fixAfterRemove(node)
}
// 再删除
if(node.parent != null){
if(node == node.parent.left){
node.parent.left = null;
}else{
node.parent.right = null;
}
node = null;
}
}
}
successor方法
/**
* 获取后继节点
*/
private RBNode successor(RBNode node) {
if (node == null) {
return null;
} else if (node.right != null) {
RBNode p = node.right;
while (p.left != null) {
p = p.left;
}
return p;
} else {
RBNode p = node.parent;
RBNode ch = node;
while (p != null && ch == p.right) {
ch = p;
p = p.parent;
}
return p;
}
}
fixAfterRemove方法
/**
* * 2-3-4树删除操作：
* * 1.情况一：自己能搞定的，对应叶子节点是3节点和4节点
* * 2.情况二：自己搞不定，需要兄弟借，但是兄弟不借，找父亲借，父亲下来，然后兄弟找一个人去代替父亲当家
* * 3.情况三：跟兄弟借，兄弟也没有
*
* @param x
*/
private void fixAfterRemove(RBNode x) {
//节点不为根节点且节点为黑色才进行调整
while (x != root && colorOf(x) == BLACK) {
//x是左孩子
if (x == leftOf(parentOf(x))) {
//找到兄弟节点
RBNode sib = rightOf(parentOf(x));
//判断此时的兄弟节点是否是真正的兄弟节点，若现在的兄弟节点为红色则需要进行调整
if (colorOf(sib) == RED) {
setColor(sib,BLACK);
setColor(parentOf(x),RED);
leftRotate(parentOf(x)); // 左旋一次
sib = rightOf(parentOf(x)); // 找到真正的兄弟节点
}
//走到这里则是真正的兄弟节点
//情况三-找兄弟借，兄弟没得借
//兄弟节点的左右两个节点为黑色，当为空的时候就是黑色
if (colorOf(leftOf(sib)) ==BLACK && colorOf(rightOf(sib))== BLACK ){
//向上递归,当成整体为红色找到对应兄弟节点
setColor(sib,RED);
x = parentOf(x);
}else {
//情况2：找兄弟借，有得借
//当前兄弟节点的右孩子为空
if(colorOf(rightOf(sib)) == BLACK){
// 右孩子为空，则左孩子肯定不为空
// 兄弟节点 先要左一次右旋
setColor(sib,RED);
setColor(leftOf(sib),BLACK);
rightRotate(sib);
// 重新调整叔叔节点的位置
sib = rightOf(parentOf(x));
}
//变色 兄弟节点是3节点或者4节点都要旋转一次
setColor(sib,colorOf(parentOf(x)));
setColor(parentOf(x),BLACK);
setColor(rightOf(sib),BLACK);
//左旋
leftRotate(parentOf(x));
x= root; //结束循环 递归针对的是情况3
}
} else {
//x是右孩子
//找到兄弟节点
RBNode sib = leftOf(parentOf(x));
//判断此时的兄弟节点是否是真正的兄弟节点，若现在的兄弟节点为红色则需要进行调整
if (colorOf(sib) == RED) {
setColor(sib,BLACK);
setColor(parentOf(x),RED);
rightRotate(parentOf(x)); // 右旋一次
sib = leftOf(parentOf(x)); // 找到真正的兄弟节点
}
//走到这里则是真正的兄弟节点
//情况三-找兄弟借，兄弟没得借
//兄弟节点的右右两个节点为黑色，当为空的时候就是黑色
if (colorOf(rightOf(sib)) ==BLACK && colorOf(leftOf(sib))== BLACK ){
//向上递归,当成整体为红色找到对应兄弟节点
setColor(sib,RED);
x = parentOf(x);
}else {
//情况2：找兄弟借，有得借
//当前兄弟节点的右孩子为空
if(colorOf(leftOf(sib)) == BLACK){
// 右孩子为空，则右孩子肯定不为空
// 兄弟节点 先要右一次右旋
setColor(sib,RED);
setColor(rightOf(sib),BLACK);
leftRotate(sib);
// 重新调整叔叔节点的位置
sib = leftOf(parentOf(x));
}
//变色 兄弟节点是3节点或者4节点都要旋转一次
//这里的意思就是设置的跟子节点相反的颜色，子节点是黑色那么这个就是红色
setColor(sib,colorOf(parentOf(x)));
setColor(parentOf(x),BLACK);
setColor(leftOf(sib),BLACK);
//右旋
rightRotate(parentOf(x));
x= root; //结束循环 递归针对的是情况3
}
}
}
}
HashMap详解
类图结构
设计原理
HashMap是根据Hash表的Map接口实现的，以key-value存储形式存在，主要用来存放键值对。HashMap的实现不是同步的，所以线程是不安全的（其中key、value都可为空且无序）。
jdk8之前：HashMap是由数组+链表，数组是HashMap的主体，在元素添加到数组的时候会计算hash，并添加到数组对应下标位置，但会出现两个元素计算出来的hash一样，这样就出现了哈希冲突。为了解决哈希冲突的情况，则对于数组上的每个元素结构为一个链表，当链表的长度大于阙值（默认为8）且数组的长度大于64时则链表会转换为红黑树。
注意：
链表转换为红黑树之前会判断阙值大于8且数组长度小于64，此时并不会将链表变为红黑树，而是选择数组扩容。
这样做的目的是避免红黑树的结构，因为红黑树的结构是自平衡树，在添加和删除节点的时候会进行旋转和变色的操作来进行平衡。这样的开销也不小，反而效率会下降，在数组长度小于64时使用链表结构搜索时间相对要快些，效率更高。综上所述，为了提高性能和减少搜索时间，因此才在阙值大于8且数组长度小于64时才进行红黑树转换（详情见treefyBin（）方法）
HashMap特点
- 存储无序
- 键和值位置可以是null，键位置只能存在一个null
- 键位置唯一
- jdk8前：链表+数组，jdk8后：链表+数组+红黑树
- 阙值>8且数组长度大于64，才将链表转换为红黑树，变成红黑树的目的是为了高效查询
扩容
源码分析
成员变量
/**
* 默认的初始容量是16 1 << 4 相当于 1*2的4次方
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 集合最大容量
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认的负载因子（默认值 0.75）
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 当桶（bucket）上的结点数大于这个值时会转为红黑树
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 当桶（bucket）上的结点数小于这个值，树转为链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 桶中结构转化为红黑树对应的数组长度最小的值
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 存储元素的数组,table 用来初始化（必须是二的n次幂）
*/
transient Node<K,V>[] table;
/**
* 存放具体元素的集合
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* HashMap 中存放元素的个数,存放元素的个数，注意这个不等于数组的长度
*/
transient int size;
/**
* 每次扩容和更改 map 结构的计数器，用来记录 HashMap 的修改次数
*/
transient int modCount;
/**
* 用来调整大小下一个容量的值计算方式为（容量*负载因子）
* 临界值 当实际大小（容量*负载因子）超过临界值时，会进行扩容
*/
int threshold;
/**
* 哈希表的负载因子
*/
final float loadFactor;
构造方法
HashMap（）
构造一个空的HashMap，默认初始容量为16、默认负载因子为0.75
public HashMap() {
// 将默认的负载因子0.75赋值给loadFactor，并没有创建数组
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
HashMap（int initalCapacity）
构造一个具有指定的初始容量和默认负载因子（0.75）HashMap
// 指定“容量大小”的构造函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
HashMap(int initialCapacity, float loadFactor)
构造一个具有指定的初始容量和负载因子的HashMap
/*
指定“容量大小”和“负载因子”的构造函数
initialCapacity：指定的容量
loadFactor:指定的负载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
// 判断初始化容量initialCapacity是否小于0
if (initialCapacity < 0)
// 如果小于0，则抛出非法的参数异常IllegalArgumentException
throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
// 判断初始化容量initialCapacity是否大于集合的最大容量MAXIMUM_CAPACITY
if (initialCapacity > MAXIMUM_CAPACITY)
// 如果超过MAXIMUM_CAPACITY，会将MAXIMUM_CAPACITY赋值给initialCapacity
initialCapacity = MAXIMUM_CAPACITY;
// 判断负载因子loadFactor是否小于等于0或者是否是一个非数值
if (loadFactor <= 0 || Float.isNaN(loadFactor))
// 如果满足上述其中之一，则抛出非法的参数异常IllegalArgumentException
throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
// 将指定的负载因子赋值给HashMap成员变量的负载因子loadFactor
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
// 最后调用了tableSizeFor，来看一下方法实现：
/*
返回比指定初始化容量大的最小的2的n次幂
*/
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
HashMap(Map<? extends K, ? extends V> m)
包含另一个Map的构造函数
// 构造一个映射关系与指定 Map 相同的新 HashMap。
public HashMap(Map<? extends K, ? extends V> m) {
// 负载因子loadFactor变为默认的负载因子0.75
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
主要逻辑在putMapEntries()，其中的resize方法和putVal方法见Put方法中解析在后续Put方法中：
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//获取参数集合的长度
int s = m.size();
if (s > 0) {
//判断参数集合的长度是否大于0，说明大于0
if (table == null) { // 判断table是否已经初始化
// 未初始化，s为m的实际元素个数
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY);
// 计算得到的t大于阈值，则初始化阈值
if (t > threshold)
threshold = tableSizeFor(t);
}
// 已初始化，并且m元素个数大于阈值，进行扩容处理
else if (s > threshold)
resize();
// 将m中的所有元素添加至HashMap中
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
注意：
float ft = ((float)s / loadFactor) + 1.0F; 这一行代码中为什么要加 1.0F ？
s/loadFactor的结果是一个小数，为了减少resize的调用次数，所以+1.0F，为的是获取更大的容量
例如：原来集合的元素个数是 6 个，那么 6/0.75 是8，是 2 的n次幂，那么新的数组大小就是 8 了。然后原来数组的数据就会存储到长度是 8 的新的数组中了，这样会导致在存储元素的时候，容量不够，还得继续扩容，那么性能降低了，而如果 +1 呢，数组长度直接变为16了，这样可以减少数组的扩容
put方法
put方法流程如下：
- 计算hash值算出key映射到哪一个桶上
- 如果桶上没有冲突，则直接进行插入
- 如果桶上有冲突，则进行冲突处理
- 若该桶已经是红黑树了，则调用红黑树的插入方法
- 否则则使用传统的链表插入，若链表的长度达到临界值，则链转变为红黑树
- 如果桶中存在重复的键，则进行之前的value
- 如果size大于阙值threhold(size*factor),则扩容（在threhold在构造方法初始化的时候就进行了扩容是指定的容器大小最小的2的幂次大小）
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
hash方法
static final int hash(Object key) {
int h;
/*
1）如果key等于null：返回的是0.
2）如果key不等于null：首先计算出key的hashCode赋值给h，然后与h无符号右移16位后的
二进制进行按位异或得到最后的hash值
*/
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
从上面可以得知 HashMap 是支持 key 为空的，而 HashTable 是直接用 Key 来获取hashCode 所以 key 为空会抛异常。
putVal方法
/**
* hash：key 的 hash 值
* key：原始 key
* value：要存放的值
* onlyIfAbsent：如果 true 代表不更改现有的值
* evict：如果为false表示 table 为创建状态
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
/*
1）transient Node<K,V>[] table; 表示存储Map集合中元素的数组。
2）(tab = table) == null 表示将空的table赋值给tab，然后判断tab是否等于null，第一次肯定是null。
3）(n = tab.length) == 0 表示将数组的长度0赋值给n，然后判断n是否等于0，n等于0，由于if判断使用双或，满足一个即可，则执行代码 n = (tab = resize()).length; 进行数组初始化，并将初始化好的数组长度赋值给n。
4）执行完n = (tab = resize()).length，数组tab每个空间都是null。
*/
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/*
1）i = (n - 1) & hash 表示计算数组的索引赋值给i，即确定元素存放在哪个桶中。
2）p = tab[i = (n - 1) & hash]表示获取计算出的位置的数据赋值给结点p。
3) (p = tab[i = (n - 1) & hash]) == null 判断结点位置是否等于null，如果为null，则执行代码：tab[i] = newNode(hash, key, value, null);根据键值对创建新的结点放入该位置的桶中。
小结：如果当前桶没有哈希碰撞冲突，则直接把键值对插入空间位置。
*/
if ((p = tab[i = (n - 1) & hash]) == null)
// 创建一个新的结点存入到桶中
tab[i] = newNode(hash, key, value, null);
else {
// 执行else说明tab[i]不等于null，表示这个位置已经有值了
Node<K,V> e; K k;
/*
比较桶中第一个元素(数组中的结点)的hash值和key是否相等
1）p.hash == hash ：p.hash表示原来存在数据的hash值 hash表示后添加数据的hash值 比较两个hash值是否相等。
说明：p表示tab[i]，即 newNode(hash, key, value, null)方法返回的Node对象。
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
而在Node类中具有成员变量hash用来记录着之前数据的hash值的。
2）(k = p.key) == key ：p.key获取原来数据的key赋值给k key 表示后添加数据的key比较两个key的地址值是否相等。
3）key != null && key.equals(k)：能够执行到这里说明两个key的地址值不相等，那么先判断后添加的key是否等于null，如果不等于null再调用equals方法判断两个key的内容是否相等。
*/
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
/*
说明：两个元素哈希值相等，并且key的值也相等，将旧的元素整体对象赋值给e，用e来记录
*/
e = p;
// hash值不相等或者key不相等；判断p是否为红黑树结点
else if (p instanceof TreeNode)
// 放入树中
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 说明是链表结点
else {
/*
1)如果是链表的话需要遍历到最后结点然后插入
2)采用循环遍历的方式，判断链表中是否有重复的key
*/
for (int binCount = 0; ; ++binCount) {
/*
1)e = p.next 获取p的下一个元素赋值给e。
2)(e = p.next) == null 判断p.next是否等于null，等于null，说明p没有下一个元素，那么此时到达了链表的尾部，还没有找到重复的key,则说明HashMap没有包含该键，将该键值对插入链表中。
*/
if ((e = p.next) == null) {
/*
1）创建一个新的结点插入到尾部
p.next = newNode(hash, key, value, null);
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
注意第四个参数next是null，因为当前元素插入到链表末尾了，那么下一个结点肯定是null。
2）这种添加方式也满足链表数据结构的特点，每次向后添加新的元素。
*/
p.next = newNode(hash, key, value, null);
/*
1)结点添加完成之后判断此时结点个数是否大于TREEIFY_THRESHOLD临界值8，如果大于则将链表转换为红黑树。
2）int binCount = 0 ：表示for循环的初始化值。从0开始计数。记录着遍历结点的个数。值是0表示第一个结点，1表示第二个结点。。。。7表示第八个结点，加上数组中的的一个元素，元素个数是9。
TREEIFY_THRESHOLD - 1 --》8 - 1 ---》7
如果binCount的值是7(加上数组中的的一个元素，元素个数是9)
TREEIFY_THRESHOLD - 1也是7，此时转换红黑树。
*/
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 转换为红黑树
treeifyBin(tab, hash);
// 跳出循环
break;
}
/*
执行到这里说明e = p.next 不是null，不是最后一个元素。继续判断链表中结点的key值与插入的元素的key值是否相等。
*/
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
// 相等，跳出循环
/*
要添加的元素和链表中的存在的元素的key相等了，则跳出for循环。不用再继续比较了
直接执行下面的if语句去替换去 if (e != null)
*/
break;
/*
说明新添加的元素和当前结点不相等，继续查找下一个结点。
用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
*/
p = e;
}
}
/*
表示在桶中找到key值、hash值与插入元素相等的结点
也就是说通过上面的操作找到了重复的键，所以这里就是把该键的值变为新的值，并返回旧值
这里完成了put方法的修改功能
*/
if (e != null) {
// 记录e的value
V oldValue = e.value;
// onlyIfAbsent为false或者旧值为null
if (!onlyIfAbsent || oldValue == null)
// 用新值替换旧值
// e.value 表示旧值 value表示新值
e.value = value;
// 访问后回调
afterNodeAccess(e);
// 返回旧值
return oldValue;
}
}
// 修改记录次数
++modCount;
// 判断实际大小是否大于threshold阈值，如果超过则扩容
if (++size > threshold)
resize();
// 插入后回调
afterNodeInsertion(evict);
return null;
}
treeifyBin（）
当添加的节点后链表的长度大于等于8时会转换为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//转换为红黑树 tab表示数组名 hash表示哈希值
treeifyBin(tab, hash);
/*
替换指定哈希表的索引处桶中的所有链接结点，除非表太小，否则将修改大小。
Node<K,V>[] tab = tab 数组名
int hash = hash表示哈希值
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
/*
如果当前数组为空或者数组的长度小于进行树形化的阈值(MIN_TREEIFY_CAPACITY = 64)，就去扩容。而不是将结点变为红黑树。
目的：如果数组很小，那么转换红黑树，然后遍历效率要低一些。这时进行扩容，那么重新计算哈希值，链表长度有可能就变短了，数据会放到数组中，这样相对来说效率高一些。
*/
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
//扩容方法
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
/*
1）执行到这里说明哈希表中的数组长度大于阈值64，开始进行树形化
2）e = tab[index = (n - 1) & hash]表示将数组中的元素取出赋值给e，e是哈希表中指定位置桶里的链表结点，从第一个开始
*/
// hd：红黑树的头结点 tl：红黑树的尾结点
TreeNode<K,V> hd = null, tl = null;
do {
// 新创建一个树的结点，内容和当前链表结点e一致
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p; // 将新创键的p结点赋值给红黑树的头结点
else {
p.prev = tl; // 将上一个结点p赋值给现在的p的前一个结点
tl.next = p; // 将现在结点p作为树的尾结点的下一个结点
}
tl = p;
/*
e = e.next 将当前结点的下一个结点赋值给e，如果下一个结点不等于null
则回到上面继续取出链表中结点转换为红黑树
*/
} while ((e = e.next) != null);
/*
让桶中的第一个元素即数组中的元素指向新建的红黑树的结点，以后这个桶里的元素就是红黑树
而不是链表数据结构了
*/
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
总结：
- 根据hash表中的元素个数确认是扩容还是树形化
- 如果要树形化则常见相同个数的树形节点，复制内容并建立联系
- 桶中的第一个元素指向新创建的树根节点，替换桶的链表内容为树形化内容
resize方法（扩容方法-重要）
扩容机制
了解扩容机制的原理更易于理解resize方法的源码，因此我们先了解下HashMap扩容机制大概是什么样子的。
扩容是什么
对于hashMap来说，实际存储数据的其实还是数据table，它是有Node结构的数组构成。
数组初始化之后就是不可变的了，要实现其扩容就需要初始化新的数组然后进行地址的替换，但会带来新的问题-旧数组中的元素如何进行hash分配呢？
这个分配就是一次重新的hash分配，需要遍历hash表中的所有元素，是十分耗时的。因此在编写程序时应尽量避免resize。
HashMap扩容时，使用的rehash方式非常巧妙，因为每次扩容的大小是翻倍的，与原来计算的（n-1）&hash的结果相比只是多了一个bit，所以原来的数据节点要么在【原来位置】要么在【原位置+旧容量】，如下图所示是HashMap容量从16扩展到32的具体变化：
因为n变成了2倍，所以n-1的笔记范围在高位多一个bit（红色），所以index也发生了改变
rehash的优点
- 省去了重新计算hash值的时间，与原来计算的（n-1）&hash的结果相比只是多了一个bit，所以原来的数据节点要么在【原来位置】要么在【原位置+旧容量】
- 新增的1bit是0还是1可以认为是随机的，所以在resize的时候保证了rehash之后每个桶上的节点数小于原来再桶上的节点数，保证了rehash之后不会出现更严重的hash冲突，均匀的把之前冲突的节点分配到了新的桶中
什么时候扩容
当hashMap的元素超过数组长度*loadFactor（负载因子)时，就会进行数组扩容，loadFactor的默认值是0.75
resize方法源码分析
final Node<K,V>[] resize() {
// 得到当前数组
Node<K,V>[] oldTab = table;
// 如果当前数组等于null长度返回0，否则返回当前数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//当前阀值点 默认是12(16*0.75)
int oldThr = threshold;
int newCap, newThr = 0;
// 如果老的数组长度大于0
// 开始计算扩容后的大小
if (oldCap > 0) {
// 超过最大值就不再扩充了，就只好随你碰撞去吧
if (oldCap >= MAXIMUM_CAPACITY) {
// 修改阈值为int的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
/*
没超过最大值，就扩充为原来的2倍
1) (newCap = oldCap << 1) < MAXIMUM_CAPACITY 扩大到2倍之后容量要小于最大容量
2）oldCap >= DEFAULT_INITIAL_CAPACITY 原数组长度大于等于数组初始化长度16
*/
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 阈值扩大一倍
newThr = oldThr << 1; // double threshold
}
// 老阈值点大于0 直接赋值
else if (oldThr > 0) // 老阈值赋值给新的数组长度
newCap = oldThr;
else { // 直接使用默认值
newCap = DEFAULT_INITIAL_CAPACITY;//16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算新的resize最大上限
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 新的阀值 默认原来是12 乘以2之后变为24
threshold = newThr;
// 创建新的哈希表
@SuppressWarnings({"rawtypes","unchecked"})
//newCap是新的数组长度--》32
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 判断旧数组是否等于空
if (oldTab != null) {
// 把每个bucket都移动到新的buckets中
// 遍历旧的哈希表的每个桶，重新计算桶里元素的新位置
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
// 原来的数据赋值为null 便于GC回收
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 { // 采用链表处理冲突
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
// 通过上述讲解的原理来计算结点的新位置
do {
// 原索引
next = e.next;
// 这里来判断如果等于true e这个结点在resize之后不需要移动位置
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 原索引+oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 原索引放到bucket里
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 原索引+oldCap放到bucket里
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
remove方法
删除方法就是找到元素的位置，如果是链表就遍历链表找到元素之后删除，如果是红黑树就用红黑树的遍历找到后删除，树小于6的时候会转为链表
remove方法
// remove方法的具体实现在removeNode方法中，所以我们重点看下removeNode方法
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
removeNode()方法
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
// 根据hash找到位置
// 如果当前key映射到的桶不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
// 如果桶上的结点就是要找的key，则将node指向该结点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
// 说明结点存在下一个结点
if (p instanceof TreeNode)
// 说明是以红黑树来处理的冲突，则获取红黑树要删除的结点
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
// 判断是否以链表方式处理hash冲突，是的话则通过遍历链表来寻找要删除的结点
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
// 比较找到的key的value和要删除的是否匹配
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
// 通过调用红黑树的方法来删除结点
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
// 链表删除
tab[index] = node.next;
else
p.next = node.next;
// 记录修改次数
++modCount;
// 变动的数量
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
get方法
get（Object key）
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
getNode方法
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 如果哈希表不为空并且key对应的桶上不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
/*
判断数组元素是否相等
根据索引的位置检查第一个元素
注意：总是检查第一个元素
*/
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 如果不是第一个元素，判断是否有后续结点
if ((e = first.next) != null) {
// 判断是否是红黑树，是的话调用红黑树中的getTreeNode方法获取结点
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
// 不是红黑树的话，那就是链表结构了，通过循环的方法判断链表中是否存在该key
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
常见问题
- HashMap中hash函数是怎么实现的？还有哪些hash函数的实现方式？我
- 两个对象的hashCode相等时会怎样？
- 什么是哈希碰撞，如何解决哈希碰撞？
- 如果两个键的hashCode相同，如何存储键值对？
扫一扫
4842
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
