前言
前言点击此处查看:
http://blog.csdn.net/wang7807564/article/details/79113195
HashMap
Java的HashMap实现的数据结构是一个哈希表,其解决哈希冲突的方法是拉链法,使用的哈希函数是取模法。与常规的直接取模法不同,HashMap是通过位运算来实现取模的。这部分思想与ArrayDeque的实现原理是类似的。
HashMap的容量都是符合以2为底数的指数函数,也就是说HashMap的容量都是2的n次幂。这样做的好处是,2的n次幂的数减1之后,可以分为两半部分,前半部分的二进制位都为0,后半部分的都为1.例如2的3次幂为8,如果是8位的有符号数则二进制形式是0x0000 1000,减1后得7,其二进制形式是0x0000 0111.
那么,如果将7与任何数字进行二进制与(AND)运算,那么计算后的结果范围一定是0~7之间的,这样将其作为掩码来使用,就起到了取模的效果。
除此之外,HashMap还定义了几个常量:
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;//负载因子
static final int TREEIFY_THRESHOLD = 8; //树化临界值
static final int UNTREEIFY_THRESHOLD = 6; //非树化临界值
static final int MIN_TREEIFY_CAPACITY = 64; //最小树化容量
常量说明
我们之前提到过,HashMap解决哈希冲突的方法是拉链法,所谓拉链法就是将数组作为若干个桶(bin),通过哈希函数来将一个K映射到一个与之向对应的桶中,在桶中查找元素,效率就会很高。添加元素时,将元素向桶内追加,追加的方式是用链表来实现的。这样就可以动态增加节点了,而且还解决了存入元素数量增加造成的哈希冲突。
DEFAULT_INITIAL_CAPACITY 定义的是默认桶的数量,前面说过,桶的数量一定是2的n次幂.
MAXIMUM_CAPACITY 是定义存储元素的极限值,但是并不意味着HashMap只能存储这么多元素,HashMap的理论最大存储数量实际上是2^32.这主要是因为这段代码:
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;//达到极限时,将threshold置为Integer.MAX_VALUE
return;//当HashMap的容量已经是2的31次方的时候,直接返回,不再继续扩容
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable);
table = newTable;
threshold = (int)(newCapacity * loadFactor);
}
上述代码是HashMap的自动扩容方法,其中loadFactor即是负载因子,其默认值为上述定义的0.75,意思是当HashMap中实际存储的元素数量达到其最大容量的0.75时,则进行扩容。因为如果容量过小,会经常造成哈希冲突,如果容量过大又很浪费空间,故而找到一个平衡值,即为负载因子。
JDK 8的改进
自从Java SE 8开始,JDK的代码将HashMap的实现进一步改写了,主要改写的内容是:
但是,如果每个桶内链表的元素数量过多,就会使查找效率退化,因为链表查找的时间复杂度是O(n),而当n比较大的时候,HashMap的查找效率就要受累了,这将丧失HashMap快速查找的特性。
于是,当每个桶中链表元素的数量过多的时候,就会将桶内的链表改为红黑树的数据结构,这个过程称之为链表的树化(treeify).这部分的实现与TreeMap类似,红黑树的时间复杂度是O(logn),当n比较大的时候,查找效率就会得到提升,但是,却牺牲了插入时的效率。
故而,为了权衡利弊,引入了阈值作为判断,也就是TREEIFY_THRESHOLD常量所定义的,当桶中的元素数量达到这个阈值时,将链表进行树化。而当桶内的元素数量小于UNTREEIFY_THRESHOLD时,将红黑树改为链表。
代码实现
拉链法存储数据结构:
//链表的数据结构
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;
}
}
//存储结构
transient Node<K,V>[] 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;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)//使用位运算来达到取模的效果
tab[i] = newNode(hash, key, value, null);
//添加桶中首个元素的节点
else {
Node<K,V> e; K k;
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中并没有被实现:
// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
取出元素:
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
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;
}
其中,树化后,寻找某个节点的方法是:
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
if ((ph = p.hash) > h)
p = pl;
else if (ph < h)
p = pr;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.find(h, k, kc)) != null)
return q;
else
p = pl;
} while (p != null);
return null;
}
Hashtable
由于HashMap的所有方法都没有加锁,因此是线程不安全的。Hashtable是一种相对原始一点的哈希表数据结构的实现,实现的方法是线程安全的,可以用于少量并发的场景。但是,不需要使用线程安全的场景下,使用HashMap而避免使用Hashtable.
另外,HashMap可以把null作为Key,而Hashtable不可以将null作为Key,否则会抛出NullPointerException异常。
Hashtable在实现的时候并不是像HashMap一样设计得足够精巧,Hashtable是一种对哈希表数据结构的简单实现,使用synchronized关键字修饰了方法,从而实现了线程安全。
其在采用的哈希函数也是取模法,避免哈希冲突的方法同样是拉链法。在设计Hashtable类中桶的数量的时候,不要求其是2的n次幂数值,因此在取模的时候并不是像HashMap一样使用位运算,故而效率同时也会降低很多,其默认的桶数量是11,负载因子同样为0.75.
@SuppressWarnings("unchecked")
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;//直接取模
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;//遍历链表
}
}
return null;
}
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {//Key不能为null
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;//直接取模
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;//替换旧值
return old;
}
}
addEntry(hash, key, value, index);//添加新值
return null;
}
WeakHashMap
WeakHashMap在代码层面实现的是弱引用,除了具有HashMap的特点,还具有弱引用的特点:
当系统将要出现OOM的时候,WeakHashMap中的元素会被垃圾回收器回收掉。
这种特点通常被作为缓存来使用,其在代码层面是这样实现弱引用:
private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>
但是,虽然在集合类中存在WeakHashMap,但是却不存在WeakHashSet这样的类,如果想要实现类似的效果,使用下面的方法:
Collections.newSetFromMap(Map<E,Boolean> map);
//该方法可以将任何 Map包装成一个Set.