Java源码阅读之HashMap（1）
表结构的第一部分，HashMap。
/**
* HashMap是基于Map接口的实现类，允许克隆和序列化操作。
* HashMap是非线程安全的，键和值都允许为null，但是键为null的键值对会被放在最前面。
* HashMap不能保证存储的键值对的顺序是一直保持不变的。
* HashMap的操作性能与两个因素有关，桶的大小和负载因子的大小，为了保证性能，请不要负载因子设置的过小，
* 或者在初始化的时候将桶设置的过大。
*/
public class HashMap extends AbstractMap
implements Map, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
/**
* 默认初始化桶的大小 16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
/**
* 桶的最大容量 2的30次幂
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 负载因子，当桶内的元素比例达到该值的时候就会进行扩容
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 当桶内节点的数量超过这个值，HashMap的数据结构会由链表转换为红黑树
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 当桶内节点的数量小于这个值的时候，HashMap的数据结构会由红黑树转换为链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 桶的数据结构转化为红黑树时table的最小值
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* HashMap底层的基本组成元素，用于存储键值对
*/
static class Node implements Map.Entry {
final int hash; // 存储key的hash值
final K key; // key值
V value; // value值
Node next; // 链表结构中指向下一个节点的指针
// 构造函数
Node(int hash, K key, V value, Node 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; }
返回当前node的hash值
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
// 判断当前节点与o是否相等，如果o和当前节点不是同一个对象，必须两者
// key和value同时相等才算o和当前节点相等
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;
}
}
/**
* 返回key的hash值
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
* 如果x实现了Comparable接口，那么返回x的类类型，否则返回null
*/
static Class comparableClassFor(Object x) {
if (x instanceof Comparable) {
Class c; Type[] ts, as; Type t; ParameterizedType p;
if ((c = x.getClass()) == String.class) // bypass checks
return c;
if ((ts = c.getGenericInterfaces()) != null) {
for (int i = 0; i < ts.length; ++i) {
if (((t = ts[i]) instanceof ParameterizedType) &&
((p = (ParameterizedType)t).getRawType() ==
Comparable.class) &&
(as = p.getActualTypeArguments()) != null &&
as.length == 1 && as[0] == c) // type arg is c
return c;
}
}
}
return null;
}
/**
* 如果k和x属于同一个类的对象，返回k.compareTo(x)的结果，否则返回0
*/
@SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable
static int compareComparables(Class kc, Object k, Object x) {
return (x == null || x.getClass() != kc ? 0 :
((Comparable)k).compareTo(x));
}
/**
* 如果cap为2的幂，那么返回cap否则返回大于cap的最小的一个2的幂
*/
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初始化后首次使用存储键值对的数组。
*/
transient Node[] table;
/**
* 用于存放键值对的集合
*/
transient Set> entrySet;
/**
* 当前对象包含的键值对数量。
*/
transient int size;
/**
* 这个集合被修改过的次数。
*/
transient int modCount;
/**
* 下一个需要调整桶大小的值，当键值对数量达到此值时需要进行扩容（容量*负载因子）
*/
int threshold;
/**
* 负载因子，非默认
*/
final float loadFactor;
/**
* 构造函数，需要指定初始化桶大小和负载因子大小
*/
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;
}
/**
* 使用m的键值对构造一个新的hashMap对象，负载因子为默认负载因子，桶的大小为至少容纳下m的键值对
*/
public HashMap(Map m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
/**
* 将m中的键值对存入当前HashMap对象中
*/
final void putMapEntries(Map m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // 计算下次扩容需要增加多大空间
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize(); //如果m的大小大于下次扩容需要增加的空间，重新进行扩容
for (Map.Entry e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
/**
* 返回当前HashMap对象中存储的键值对数量
*/
public int size() {
return size;
}
/**
* 判断当前HashMap对象是否为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 给定key值，从当前HashMap对象中取出Key对应的value值
*/
public V get(Object key) {
Node e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* 根据给定的hash和key值获取节点信息，适用于hash冲突的时候
*/
final Node getNode(int hash, Object key) {
Node[] tab; Node first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // 检查第一个节点是否符合条件
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode)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;
}