Hashmap继承实现的类接口
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {}
继承AbstractMap ，实现Cloneable、Serializable接口
AbstractMap
AbstractMap 是 Map 接口的的实现类之一，也是LinkedHashMap , HashMap, TreeMap, ConcurrentHashMap 等类的父类。
AbstractMap 的成员变量
transient volatile Set<K> keySet;
transient volatile Collection<V> values;
Cloneable
首先，在java中创建对象的方式有四种：
一种是new，通过new关键字在堆中为对象开辟空间，在执行new时，首先会看所要创建的对象的类型，知道了类型，才能知道需 要给这个对象分配多大的内存区域，分配内存后，调用对象的构造函数，填充对象中各个变量的值，将对象初始化，然后通过构造方法返回对象的地址；
另一种是clone，clone也是首先分配内存，这里分配的内存与调用clone方法对象的内存相同，然后将源对象中各个变量的值，填充到新的对象中，填充完成后，clone方法返回一个新的地址，这个新地址的对象与源对象相同，只是地址不同。
另外还有输入输出流，反射构造对象等
浅拷贝：使用一个已知实例对新创建实例的成员变量逐个赋值，这个方式被称为浅拷贝。
深拷贝：当一个类的拷贝构造方法，不仅要复制对象的所有非引用成员变量值，还要为引用类型的成员变量创建新的实例，并且初始化为形式参数实例值。这个方式称为深拷贝（即引用成员变量也要实现Cloneable接口，不然克隆后的引用仍指向同一实例对象）
Serializable
实现该接口才可以序列化，ouputstream
对象的寿命通常随着生成该对象的程序的终止而终止，有时候需要把在内存中的各种对象的状态（也就是实例变量，不是方法）保存下来，并且可以在需要时再将对象恢复。虽然你可以用你自己的各种各样的方法来保存对象的状态，但是Java给你提供一种应该比你自己的好的保存对象状态的机制，那就是序列化。
Java 序列化技术可以使你将一个对象的状态写入一个Byte 流里（系列化），并且可以从其它地方把该Byte 流里的数据读出来（反序列化）。
hash(哈希运算) 一些位运算
这个方法的返回值还是一个哈希值，为了更加均匀
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
n = table.length;
index = （n-1） & hash
a亦或b计算 结果为1的几率为1/2,0的几率为1/2 所以，进行亦或计算，得到的结果肯定更为平均，不会偏向0或者偏向1，更为散列
右移16位进行亦或计算，我将其拆分为两部分，前16位的亦或运算，和后16位的亦或运算， 后16位的亦或运算，即原hashcode后16位与原hashcode前16位进行亦或计算，得出的结果，前16位和后16位都有参与其中，保证了 32位全部进行计算。
& 位与 两个比特位都为 1 时，结果才为 1，否则为 0 （位与操作满足交换律和结合律，甚至分配律）
| 位或 两个比特位都为 0 时，结果才为 0，否则为 1 （位或操作满足交换律和结合律，甚至分配律）
~ 位非 即按位取反，1 变 0，0 变 1
^ 异或 两个比特位相同时（都为 0 或都为 1）为 0，相异为 1（异或操作满足交换律和结合律，甚至分配律。任何整数和自己异或的结果为 0，任何整数与 0 异或值不变）
<< 左移 将所有的二进制位按值向←左移动若干位，左移操作与正负数无关，它只是傻傻地将所有位按值向左移动，高位舍弃，低位补 0
>> 右移 将所有的二进制位按值向右→移动若干位，低位直接舍弃，跟正负无关，而高位补 0 还是补 1 则跟被操作整数的正负相关，正数补 0 ，负数补 1
>>> 无符号右移 将所有的二进制位按值向右→移动若干位，低位直接舍弃，跟正负无关，高位补 0 ，也跟正负无关
判断奇偶数
(n & 1) == 1
省去中间变量交换两整数的值（因为^满足分配率）
public void swap(){
int a = 1, b = 2;
a ^= b;
b ^= a;//b == 1
a ^= b;//a == 2
System.out.println("a:" + a);//a:2
System.out.println("b:" + b);//b:1
}
变换符号，正变负，负变正
只需对待操作数应用取反操作后再加 1 即可
public void negate(){
int a = -10, b = 10;
System.out.println(~a + 1);//10
System.out.println(~b + 1);//-10
}
求绝对值
对于负数可以通过上面变换符号的操作得到绝对值， 正数直接返回即可，因此我们要先判断符号位来得知当前数的正负。
public int abs(int a){
int i = a >> 31;//得到符号位，0 为正数，-1 为负数
return i == 0 ? a : (~a + 1);//符号位为 0 直接返回，否则返回 ~a + 1
}
或者，n>>31 取得n的符号，若n为正数，n>>31等于0，若n为负数，n>>31等于-1 若n为正数 n^0-0 数不变，若n为负数n^-1 需要计算n和-1的补码，异或后再取补码， 结果n变号并且绝对值减1，再减去-1就是绝对值
public int abs(int a){
return a ^ (a >> 31)) - (a >> 31);
}
lowbit(获取二进制数字 最低位1 的位置)
负数 补码符号位是1，其它位是对应正数的二进制的取反加一
补码 = 反码 + 1；
lowbit(x) = x & (-x)
构造方法
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
链表树化的参数
static final int TREEIFY_THRESHOLD = 8;
链表不树化的参数
static final int UNTREEIFY_THRESHOLD = 6;
hashmap数组最小 树化参数
static final int MIN_TREEIFY_CAPACITY = 64;
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);
}
返回为2的幂的数，初试的hashmap容量要求。
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;
}
先来分析有关n位操作部分：先来假设n的二进制为01xxx…xxx。接着
对n右移1位：001xx…xxx，再位或：011xx…xxx
对n右移2为：00011…xxx，再位或：01111…xxx
此时前面已经有四个1了，再右移4位且位或可得8个1
同理，有8个1，右移8位肯定会让后八位也为1。
综上可得，该算法让最高位的1后面的位全变为1。
最后再让结果n+1，即得到了2的整数次幂的值了。
现在回来看看第一条语句：
int n = cap - 1;
让cap-1再赋值给n的目的是另找到的目标值大于或等于原值。例如二进制1000，十进制数值为8。如果不对它减1而直接操作，将得到答案10000，即16。显然不是结果。减1后二进制为111，再进行操作则会得到原来的数值1000，即8。
Node节点
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;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
putval（插入数据）
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// tab 当前hashmap的散列表
// p 当前散列表的元素（要插入数据的散列表下标node）
// n 散列表数组的长度
// i 路由寻址的位置 也就是插入的位置
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 延迟初始化，判定是否初始化散列表，散列表最占内存 可能new不插入数据
if ((tab = table) == null || (n = tab.length) == 0)
// 初次调用建散列表
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// 获取hash值在散列表的下标，如果改下标没数据，就直接插入
tab[i] = newNode(hash, key, value, null);
else {
//代表要插入的数据所在的位置是有内容的
// e node 临时元素 k 临时的一个key
Node<K,V> e; K k;
// 表示桶位中的该元素 与要插入的key完全一致，后续需要就直接替换或者不变
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 判断node是否是树节点，树节点的插法
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;
}
}
// e为空的话，说明直接遍历到空节点并直接创建一个新的节点
// 如果e不为空，就说明当前节点的key与插入node的key相同 需要替换或者不变。
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;
}
扩容resize()
final来修饰类 方法 属性都表示其值不可变，也就是说类不可继承，方法不可重写，属性不可覆盖。
final Node<K,V>[] resize() {
// 扩容前的散列表
Node<K,V>[] oldTab = table;
// 扩容前散列表的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 扩容前的阈值（触发扩容的数值） capacity
int oldThr = threshold;
// 计算出新的tab长度 与新的扩容阈值
int newCap, newThr = 0;
// oldCap > 0 tab已经初始化过，进行正常的扩容
if (oldCap > 0) {
// 超过了最大阈值 返回旧表
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 容量左移一位实现翻倍,
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 如果散列表没初始化，oldcap=0 oldthreshold>0 指定了初试oldthreshold
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// oldcap=0 oldthreshold=0
else { // zero initial threshold signifies using defaults
// oldThr没有初始化，
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"})
// 初始化一个长度为newCap的数组newTab，并把table=newTab
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 本次扩容前 tab 不为null
if (oldTab != null) {
// 遍历tab 可能是单个数据 链表 红黑树 或者空
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 第一种情况 当前桶位只有一个元素，直接计算出旧node的hash在新散列表所在位置
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
// 第三种 如果是链表的情况下，则进行下面的链表数据转移的操作 因为新的长度加一了
// e.hash & tab.length - 1
// tab.length（也就是newCap 增长两倍）长度变化后，最前面那一位可能是0也可能是1 所以要拆成两个链表)
// 假设原长度 --> 0b 10000 & hash
// hash --> 0b 11110 到二倍下标的桶位置
// hash --> 0b 01110 保留在原来的桶位置
// 低位链表
Node<K,V> loHead = null, loTail = null;
// 高位链表
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// hash ->
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) {
// 重新计算出所对应的数组下标值newTab[j + oldCap],存放需要更改数组下标位置的链表头节点
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
get 获取数据
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 判断tab不为空，查询散列表桶位不为空
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) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 第三种 后续节点不为空，链表
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
remove
public boolean remove(Object key, Object value) {
return removeNode(hash(key), key, value, true, true) != null;
}
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;
// 说明node桶位中有数据。。
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;
// 第一种情况 当前桶位 就是你要删除的数据
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 {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
// 节点不为空 说明有需要删除的元素
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
// node节点是树类型的
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
// 节点为链表形 移除node为首节点
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
getOrDefault
// 存在放入原值，不存在放入default
public V getOrDefault(Object key, V defaultValue) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}
遍历hashmap
abstract class HashIterator {
Node<K,V> next; // next entry to return
Node<K,V> current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
HashIterator() {
expectedModCount = modCount;
Node<K,V>[] t = table;
current = next = null;
index = 0;
if (t != null && size > 0) { // advance to first entry
do {} while (index < t.length && (next = t[index++]) == null);
}
}
public final boolean hasNext() {
return next != null;
}
final Node<K,V> nextNode() {
Node<K,V>[] t;
Node<K,V> e = next;
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
if ((next = (current = e).next) == null && (t = table) != null) {
do {} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
public final void remove() {
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;
}
}
final class KeyIterator extends HashIterator
implements Iterator<K> {
public final K next() { return nextNode().key; }
}
final class ValueIterator extends HashIterator
implements Iterator<V> {
public final V next() { return nextNode().value; }
}
final class EntryIterator extends HashIterator
implements Iterator<Map.Entry<K,V>> {
public final Map.Entry<K,V> next() { return nextNode(); }
}
// array,set
// 普通for 循环:
// foreach(Interger i :list)
//
// 获取 value的iterator，然后判断 hasNext(), 取出第一个元素next()
Iterator it = hashmap.values().iterator();
while (it.hasNext()) {
value = (Integer) it.next();
System.out.println("value:" + value);
}
// 获取 key的iterator
Iterator it = hashmap.keys().iterator();
while (it.hasNext()) {
key = (String) it.next();
value = (Integer) hMap.get(key);
System.out.println("key:" + key + "---" + "value:" + value);
}
// 获取entry的iterator
Iterator it = hMap.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
key = (String) entry.getKey();
value = (Integer) entry.getValue();
System.out.println("key:" + key + "---" + "value:" + value);
}
为什么HashMap使用红黑树而不使用AVL树
AVL树更加严格平衡，因此可以提供更快的査找效果。因此，对于查找密集型任务使用AVL树没毛病。 但是对于插入密集型任务，红黑树要好一些。
通常，AVL树的旋转比红黑树的旋转更难实现和调试。
在CurrentHashMap中是加锁了的，实际上是读写锁，如果写冲突就会等待，
真正的区别在于在任何添加/删除操作时完成的旋转操作次数。
在AVL树中，从根到任何叶子的最短路径和最长路径之间的差异最多为1。在红黑树中，差异可以是2倍。
两个都给O（log n）查找，但平衡AVL树可能需要O（log n）旋转，而红黑树将需要最多两次旋转使其达到平衡（尽管可能需要检查O（log n）节点以确定旋转的位置）。旋转本身是O（1）操作，因为你只是移动指针。
为什么HashMap使用红黑树而不使用B+树
B和B+树主要用于数据存储在磁盘上的场景，比如数据库索引就是用B+树实现的。这两种数据结构的特点就是树比较矮胖，每个结点存放一个磁盘大小的数据，这样一次可以把一个磁盘的数据读入内存，减少磁盘转动的耗时，提高效率。而红黑树多用于内存中排序，也就是内部排序。
树看重两个性能 插入和查找。插入时有可能要调整树的结构 重新平衡树，B+树 调整树的结构慢一些，所以B+树插入慢，查找快；红黑树插入快 ，查找慢。
扫一扫
85
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
