Java基础之Map实现篇
HashMap
HashMap概述
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
HashMap 继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。
HashMap 的实现不是同步的，这意味着它不是线程安全的。它的key、value都可以为null。此外，HashMap中的映射不是有序的。
HashMap 的实例有两个参数影响其性能：“初始容量” 和 “加载因子”。容量 是哈希表中桶的数量，初始容量 只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。
HashMap数据结构
java.lang.Object
↳ java.util.AbstractMap
↳ java.util.HashMap
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable { } 
从图中可以看出：
1. HashMap继承于AbstractMap类，实现了Map接口。Map是”key-value键值对”接口，AbstractMap实现了”键值对”的通用函数接口。
2. HashMap是通过”拉链法”实现的哈希表。它包括几个重要的成员变量：table, size, threshold, loadFactor, modCount。
table是一个Entry[]数组类型，而Entry实际上就是一个单向链表。哈希表的”key-value键值对”都是存储在Entry数组中的。
size是HashMap的大小，它是HashMap保存的键值对的数量。
threshold是HashMap的阈值，用于判断是否需要调整HashMap的容量。threshold的值=”容量*加载因子”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
loadFactor就是加载因子。
modCount是用来实现fail-fast机制的。
fail-fast 机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件(http://www.cnblogs.com/skywang12345/p/3308762.html)
HashMap的构造函数
HashMap共有4个构造函数
// 默认构造函数。
HashMap()
// 指定“容量大小”的构造函数
HashMap(int capacity)
// 指定“容量大小”和“加载因子”的构造函数
HashMap(int capacity, float loadFactor)
// 包含“子Map”的构造函数
HashMap(Map map)HashMap的API
void clear()
Object clone()
boolean containsKey(Object key)
boolean containsValue(Object value)
Set> entrySet()
V get(Object key)
boolean isEmpty()
Set keySet()
V put(K key, V value)
void putAll(Map map)
V remove(Object key)
int size()
Collection values() HashMap源码解析
http://www.cnblogs.com/skywang12345/p/3310835.html
为了更了解HashMap的原理，下面对HashMap源码代码作出分析。
在阅读源码时，建议参考后面的说明来建立对HashMap的整体认识，这样更容易理解HashMap
package java.util;
import java.io.*;
public class HashMap
extends AbstractMap
implements Map, Cloneable, Serializable
{
// 默认的初始容量是16，必须是2的幂。
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 存储数据的Entry数组，长度是2的幂。
// HashMap是采用拉链法实现的，每一个Entry本质上是一个单向链表
transient Entry[] table;
// HashMap的大小，它是HashMap保存的键值对的数量
transient int size;
// HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）
int threshold;
// 加载因子实际大小
final float loadFactor;
// HashMap被改变的次数
transient volatile int modCount;
// 指定“容量大小”和“加载因子”的构造函数
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// HashMap的最大容量只能是MAXIMUM_CAPACITY
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// 找出“大于initialCapacity”的最小的2的幂
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
// 设置“加载因子”
this.loadFactor = loadFactor;
// 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
threshold = (int)(capacity * loadFactor);
// 创建Entry数组，用来保存数据
table = new Entry[capacity];
init();
}
// 指定“容量大小”的构造函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
// 默认构造函数。
public HashMap() {
// 设置“加载因子”
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
// 创建Entry数组，用来保存数据
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init();
}
// 包含“子Map”的构造函数
public HashMap(Map m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
// 将m中的全部元素逐个添加到HashMap中
putAllForCreate(m);
}
static int hash(int h) {
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
// 返回索引值
// h & (length-1)保证返回值的小于length
static int indexFor(int h, int length) {
return h & (length-1);
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
// 获取key对应的value
public V get(Object key) {
if (key == null)
return getForNullKey();
// 获取key的hash值
int hash = hash(key.hashCode());
// 在“该hash值对应的链表”上查找“键值等于key”的元素
for (Entry e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}
return null;
}
// 获取“key为null”的元素的值
// HashMap将“key为null”的元素存储在table[0]位置！
private V getForNullKey() {
for (Entry e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
// HashMap是否包含key
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
// 返回“键为key”的键值对
final Entry getEntry(Object key) {
// 获取哈希值
// HashMap将“key为null”的元素存储在table[0]位置，“key不为null”的则调用hash()计算哈希值
int hash = (key == null) ? 0 : hash(key.hashCode());
// 在“该hash值对应的链表”上查找“键值等于key”的元素
for (Entry e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
// 将“key-value”添加到HashMap中
public V put(K key, V value) {
// 若“key为null”，则将该键值对添加到table[0]中。
if (key == null)
return putForNullKey(value);
// 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry e = table[i]; e != null; e = e.next) {
Object k;
// 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 若“该key”对应的键值对不存在，则将“key-value”添加到table中
modCount++;
addEntry(hash, key, value, i);
return null;
}
// putForNullKey()的作用是将“key为null”键值对添加到table[0]位置
private V putForNullKey(V value) {
for (Entry e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 这里的完全不会被执行到!
modCount++;
addEntry(0, null, value, 0);
return null;
}
// 创建HashMap对应的“添加方法”，
// 它和put()不同。putForCreate()是内部方法，它被构造函数等调用，用来创建HashMap
// 而put()是对外提供的往HashMap中添加元素的方法。
private void putForCreate(K key, V value) {
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
// 若该HashMap表中存在“键值等于key”的元素，则替换该元素的value值
for (Entry e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
// 若该HashMap表中不存在“键值等于key”的元素，则将该key-value添加到HashMap中
createEntry(hash, key, value, i);
}
// 将“m”中的全部元素都添加到HashMap中。
// 该方法被内部的构造HashMap的方法所调用。
private void putAllForCreate(Map m) {
// 利用迭代器将元素逐个添加到HashMap中
for (Iterator> i = m.entrySet().iterator(); i.hasNext(); ) {
Map.Entry e = i.next();
putForCreate(e.getKey(), e.getValue());
}
}
// 重新调整HashMap的大小，newCapacity是调整后的单位
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
// 新建一个HashMap，将“旧HashMap”的全部元素添加到“新HashMap”中，
// 然后，将“新HashMap”赋值给“旧HashMap”。
Entry[] newTable = new Entry[newCapacity];
transfer(newTable);
table = newTable;
threshold = (int)(newCapacity * loadFactor);
}
// 将HashMap中的全部元素都添加到newTable中
void transfer(Entry[] newTable) {
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {
Entry e = src[j];
if (e != null) {
src[j] = null;
do {
Entry next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null);
}
}
}
// 将"m"的全部元素都添加到HashMap中
public void putAll(Map m) {
// 有效性判断
int numKeysToBeAdded = m.size();
if (numKeysToBeAdded == 0)
return;
// 计算容量是否足够，
// 若“当前实际容量 < 需要的容量”，则将容量x2。
if (numKeysToBeAdded > threshold) {
int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
if (targetCapacity > MAXIMUM_CAPACITY)
targetCapacity = MAXIMUM_CAPACITY;
int newCapacity = table.length;
while (newCapacity < targetCapacity)
newCapacity <<= 1;
if (newCapacity > table.length)
resize(newCapacity);
}
// 通过迭代器，将“m”中的元素逐个添加到HashMap中。
for (Iterator> i = m.entrySet().iterator(); i.hasNext(); ) {
Map.Entry e = i.next();
put(e.getKey(), e.getValue());
}
}
// 删除“键为key”元素
public V remove(Object key) {
Entry e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
// 删除“键为key”的元素
final Entry removeEntryForKey(Object key) {
// 获取哈希值。若key为null，则哈希值为0；否则调用hash()进行计算
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
Entry prev = table[i];
Entry e = prev;
// 删除链表中“键为key”的元素
// 本质是“删除单向链表中的节点”
while (e != null) {
Entry next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
// 删除“键值对”
final Entry removeMapping(Object o) {
if (!(o instanceof Map.Entry))
return null;
Map.Entry entry = (Map.Entry) o;
Object key = entry.getKey();
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
Entry prev = table[i];
Entry e = prev;
// 删除链表中的“键值对e”
// 本质是“删除单向链表中的节点”
while (e != null) {
Entry next = e.next;
if (e.hash == hash && e.equals(entry)) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
// 清空HashMap，将所有的元素设为null
public void clear() {
modCount++;
Entry[] tab = table;
for (int i = 0; i < tab.length; i++)
tab[i] = null;
size = 0;
}
// 是否包含“值为value”的元素
public boolean containsValue(Object value) {
// 若“value为null”，则调用containsNullValue()查找
if (value == null)
return containsNullValue();
// 若“value不为null”，则查找HashMap中是否有值为value的节点。
Entry[] tab = table;
for (int i = 0; i < tab.length ; i++)
for (Entry e = tab[i] ; e != null ; e = e.next)
if (value.equals(e.value))
return true;
return false;
}
// 是否包含null值
private boolean containsNullValue() {
Entry[] tab = table;
for (int i = 0; i < tab.length ; i++)
for (Entry e = tab[i] ; e != null ; e = e.next)
if (e.value == null)
return true;
return false;
}
// 克隆一个HashMap，并返回Object对象
public Object clone() {
HashMap result = null;
try {
result = (HashMap)super.clone();
} catch (CloneNotSupportedException e) {
// assert false;
}
result.table = new Entry[table.length];
result.entrySet = null;
result.modCount = 0;
result.size = 0;
result.init();
// 调用putAllForCreate()将全部元素添加到HashMap中
result.putAllForCreate(this);
return result;
}
// Entry是单向链表。
// 它是 “HashMap链式存储法”对应的链表。
// 它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数
static class Entry implements Map.Entry {
final K key;
V value;
// 指向下一个节点
Entry next;
final int hash;
// 构造函数。
// 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"
Entry(int h, K k, V v, Entry n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
// 判断两个Entry是否相等
// 若两个Entry的“key”和“value”都相等，则返回true。
// 否则，返回false
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
// 实现hashCode()
public final int hashCode() {
return (key==null ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}
public final String toString() {
return getKey() + "=" + getValue();
}
// 当向HashMap中添加元素时，绘调用recordAccess()。
// 这里不做任何处理
void recordAccess(HashMap m) {
}
// 当从HashMap中删除元素时，绘调用recordRemoval()。
// 这里不做任何处理
void recordRemoval(HashMap m) {
}
}
// 新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。
void addEntry(int hash, K key, V value, int bucketIndex) {
// 保存“bucketIndex”位置的值到“e”中
Entry e = table[bucketIndex];
// 设置“bucketIndex”位置的元素为“新Entry”，
// 设置“e”为“新Entry的下一个节点”
table[bucketIndex] = new Entry(hash, key, value, e);
// 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小
if (size++ >= threshold)
resize(2 * table.length);
}
// 创建Entry。将“key-value”插入指定位置，bucketIndex是位置索引。
// 它和addEntry的区别是：
// (01) addEntry()一般用在 新增Entry可能导致“HashMap的实际容量”超过“阈值”的情况下。
// 例如，我们新建一个HashMap，然后不断通过put()向HashMap中添加元素；
// put()是通过addEntry()新增Entry的。
// 在这种情况下，我们不知道何时“HashMap的实际容量”会超过“阈值”；
// 因此，需要调用addEntry()
// (02) createEntry() 一般用在 新增Entry不会导致“HashMap的实际容量”超过“阈值”的情况下。
// 例如，我们调用HashMap“带有Map”的构造函数，它绘将Map的全部元素添加到HashMap中；
// 但在添加之前，我们已经计算好“HashMap的容量和阈值”。也就是，可以确定“即使将Map中
// 的全部元素添加到HashMap中，都不会超过HashMap的阈值”。
// 此时，调用createEntry()即可。
void createEntry(int hash, K key, V value, int bucketIndex) {
// 保存“bucketIndex”位置的值到“e”中
Entry e = table[bucketIndex];
// 设置“bucketIndex”位置的元素为“新Entry”，
// 设置“e”为“新Entry的下一个节点”
table[bucketIndex] = new Entry(hash, key, value, e);
size++;
}
// HashIterator是HashMap迭代器的抽象出来的父类，实现了公共了函数。
// 它包含“key迭代器(KeyIterator)”、“Value迭代器(ValueIterator)”和“Entry迭代器(EntryIterator)”3个子类。
private abstract class HashIterator implements Iterator {
// 下一个元素
Entry next;
// expectedModCount用于实现fast-fail机制。
int expectedModCount;
// 当前索引
int index;
// 当前元素
Entry current;
HashIterator() {
expectedModCount = modCount;
if (size > 0) { // advance to first entry
Entry[] t = table;
// 将next指向table中第一个不为null的元素。
// 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。
while (index < t.length && (next = t[index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
// 获取下一个元素
final Entry nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry e = next;
if (e == null)
throw new NoSuchElementException();
// 注意！！！
// 一个Entry就是一个单向链表
// 若该Entry的下一个节点不为空，就将next指向下一个节点;
// 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。
if ((next = e.next) == null) {
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
// 删除当前元素
public void remove() {
if (current == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Object k = current.key;
current = null;
HashMap.this.removeEntryForKey(k);
expectedModCount = modCount;
}
}
// value的迭代器
private final class ValueIterator extends HashIterator {
public V next() {
return nextEntry().value;
}
}
// key的迭代器
private final class KeyIterator extends HashIterator {
public K next() {
return nextEntry().getKey();
}
}
// Entry的迭代器
private final class EntryIterator extends HashIterator> {
public Map.Entry next() {
return nextEntry();
}
}
// 返回一个“key迭代器”
Iterator newKeyIterator() {
return new KeyIterator();
}
// 返回一个“value迭代器”
Iterator newValueIterator() {
return new ValueIterator();
}
// 返回一个“entry迭代器”
Iterator> newEntryIterator() {
return new EntryIterator();
}
// HashMap的Entry对应的集合
private transient Set> entrySet = null;
// 返回“key的集合”，实际上返回一个“KeySet对象”
public Set keySet() {
Set ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}
// Key对应的集合
// KeySet继承于AbstractSet，说明该集合中没有重复的Key。
private final class KeySet extends AbstractSet {
public Iterator iterator() {
return newKeyIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
}
// 返回“value集合”，实际上返回的是一个Values对象
public Collection values() {
Collection vs = values;
return (vs != null ? vs : (values = new Values()));
}
// “value集合”
// Values继承于AbstractCollection，不同于“KeySet继承于AbstractSet”，
// Values中的元素能够重复。因为不同的key可以指向相同的value。
private final class Values extends AbstractCollection {
public Iterator iterator() {
return newValueIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsValue(o);
}
public void clear() {
HashMap.this.clear();
}
}
// 返回“HashMap的Entry集合”
public Set> entrySet() {
return entrySet0();
}
// 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象
private Set> entrySet0() {
Set> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
// EntrySet对应的集合
// EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。
private final class EntrySet extends AbstractSet> {
public Iterator> iterator() {
return newEntryIterator();
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry) o;
Entry candidate = getEntry(e.getKey());
return candidate != null && candidate.equals(e);
}
public boolean remove(Object o) {
return removeMapping(o) != null;
}
public int size() {
return size;
}
public void clear() {
HashMap.this.clear();
}
}
// java.io.Serializable的写入函数
// 将HashMap的“总的容量，实际容量，所有的Entry”都写入到输出流中
private void writeObject(java.io.ObjectOutputStream s)
throws IOException
{
Iterator> i =
(size > 0) ? entrySet0().iterator() : null;
// Write out the threshold, loadfactor, and any hidden stuff
s.defaultWriteObject();
// Write out number of buckets
s.writeInt(table.length);
// Write out size (number of Mappings)
s.writeInt(size);
// Write out keys and values (alternating)
if (i != null) {
while (i.hasNext()) {
Map.Entry e = i.next();
s.writeObject(e.getKey());
s.writeObject(e.getValue());
}
}
}
private static final long serialVersionUID = 362498820763181265L;
// java.io.Serializable的读取函数：根据写入方式读出
// 将HashMap的“总的容量，实际容量，所有的Entry”依次读出
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{
// Read in the threshold, loadfactor, and any hidden stuff
s.defaultReadObject();
// Read in number of buckets and allocate the bucket array;
int numBuckets = s.readInt();
table = new Entry[numBuckets];
init(); // Give subclass a chance to do its thing.
// Read in size (number of Mappings)
int size = s.readInt();
// Read the keys and values, and put the mappings in the HashMap
for (int i=0; ivalue = (V) s.readObject();
putForCreate(key, value);
}
}
// 返回“HashMap总的容量”
int capacity() { return table.length; }
// 返回“HashMap的加载因子”
float loadFactor() { return loadFactor; }
} 说明:
在详细介绍HashMap的代码之前，我们需要了解：HashMap就是一个散列表，它是通过“拉链法”解决哈希冲突的。
还需要再补充说明的一点是影响HashMap性能的有两个参数：初始容量(initialCapacity) 和加载因子(loadFactor)。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
* HashMap的“拉链法”相关内容*
HashMap数据存储数组
transient Entry[] table;HashMap中的key-value都是存储在Entry数组中的。
数据节点Entry的数据结构
static class Entry implements Map.Entry {
final K key;
V value;
// 指向下一个节点
Entry next;
final int hash;
// 构造函数。
// 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"
Entry(int h, K k, V v, Entry n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
// 判断两个Entry是否相等
// 若两个Entry的“key”和“value”都相等，则返回true。
// 否则，返回false
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
// 实现hashCode()
public final int hashCode() {
return (key==null ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}
public final String toString() {
return getKey() + "=" + getValue();
}
// 当向HashMap中添加元素时，绘调用recordAccess()。
// 这里不做任何处理
void recordAccess(HashMap m) {
}
// 当从HashMap中删除元素时，绘调用recordRemoval()。
// 这里不做任何处理
void recordRemoval(HashMap m) {
}
} 从中，我们可以看出 Entry 实际上就是一个单向链表。这也是为什么我们说HashMap是通过拉链法解决哈希冲突的。
Entry 实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数。这些都是基本的读取/修改key、value值的函数。
HashMap的构造函数
// 默认构造函数。
public HashMap() {
// 设置“加载因子”
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
// 创建Entry数组，用来保存数据
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init();
}
// 指定“容量大小”和“加载因子”的构造函数
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// HashMap的最大容量只能是MAXIMUM_CAPACITY
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
// 设置“加载因子”
this.loadFactor = loadFactor;
// 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
threshold = (int)(capacity * loadFactor);
// 创建Entry数组，用来保存数据
table = new Entry[capacity];
init();
}
// 指定“容量大小”的构造函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
// 包含“子Map”的构造函数
public HashMap(Map m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
// 将m中的全部元素逐个添加到HashMap中
putAllForCreate(m);
}HashMap的遍历
遍历HashMap的键值对
第一步：根据entrySet()获取HashMap的“键值对”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。
推荐的遍历方式：
// 假设map是HashMap对象
// map中的key是String类型，value是Integer类型
Integer integ = null;
Iterator iter = map.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
// 获取key
key = (String)entry.getKey();
// 获取value
integ = (Integer)entry.getValue();
}遍历HashMap的键
第一步：根据keySet()获取HashMap的“键”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。
// 假设map是HashMap对象
// map中的key是String类型，value是Integer类型
String key = null;
Integer integ = null;
Iterator iter = map.keySet().iterator();
while (iter.hasNext()) {
// 获取key
key = (String)iter.next();
// 根据key，获取value
integ = (Integer)map.get(key);
}遍历HashMap的值
第一步：根据value()获取HashMap的“值”的集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。
// 假设map是HashMap对象
// map中的key是String类型，value是Integer类型
Integer value = null;
Collection c = map.values();
Iterator iter= c.iterator();
while (iter.hasNext()) {
value = (Integer)iter.next();
}HashMap示例
public class Test {
public static void main(String[] args) {
testHashMapAPIs();
}
private static void testHashMapAPIs() {
// 初始化随机种子
Random r = new Random();
// 新建HashMap
HashMap map = new HashMap();
// 添加操作
map.put("one", r.nextInt(10));
map.put("two", r.nextInt(10));
map.put("three", r.nextInt(10));
// 打印出map
System.out.println("map:"+map );
// 通过Iterator遍历key-value
Iterator iter = map.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
System.out.println("next : "+ entry.getKey() +" - "+entry.getValue());
}
// HashMap的键值对个数
System.out.println("size:"+map.size());
// containsKey(Object key) :是否包含键key
System.out.println("contains key two : "+map.containsKey("two"));
System.out.println("contains key five : "+map.containsKey("five"));
// containsValue(Object value) :是否包含值value
System.out.println("contains value 0 : "+map.containsValue(Integer.valueOf(0)));
// remove(Object key) ： 删除键key对应的键值对
map.remove("three");
System.out.println("map:"+map );
// clear() ： 清空HashMap
map.clear();
// isEmpty() : HashMap是否为空
System.out.println((map.isEmpty()?"map is empty":"map is not empty") );
}
}
/*
输出：
map:{two=6, one=5, three=5}
two : 6
one : 5
three : 5
size:3
contains key two : true
contains key five : false
contains value 0 : false
map:{two=6, one=5}
map is empty
*/ HashTable
HashTable概述
和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。
Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。一个类只能继承一个类，可以实现多个接口。
Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。此外，Hashtable中的映射不是有序的。
Hashtable 的实例有两个参数影响其性能：初始容量 和 加载因子。容量 是哈希表中桶 的数量，初始容量 就是哈希表创建时的容量。注意，哈希表的状态为 open：在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索。加载因子 是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示。关于何时以及是否调用 rehash 方法的具体细节则依赖于该实现。
通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查找某个条目的时间（在大多数 Hashtable 操作中，包括 get 和 put 操作，都反映了这一点）。
* Hashtable数据结构*
Hashtable的继承关系
java.lang.Object
↳ java.util.Dictionary
↳ java.util.Hashtable
public class Hashtable<K,V> extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable { } Hashtable与Map关系如下图：
从图中可以看出：
1. Hashtable继承于Dictionary类，实现了Map接口。Map是”key-value键值对”接口，Dictionary是声明了操作”键值对”函数接口的抽象类。
2. Hashtable是通过”拉链法”实现的哈希表。它包括几个重要的成员变量：table, count, threshold, loadFactor, modCount。
table是一个Entry[]数组类型，而Entry实际上就是一个单向链表。哈希表的”key-value键值对”都是存储在Entry数组中的。
count是Hashtable的大小，它是Hashtable保存的键值对的数量。
threshold是Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值=”容量*加载因子”。
loadFactor就是加载因子。
modCount是用来实现fail-fast机制的
Hashtable的构造函数
// 默认构造函数。
public Hashtable()
// 指定“容量大小”的构造函数
public Hashtable(int initialCapacity)
// 指定“容量大小”和“加载因子”的构造函数
public Hashtable(int initialCapacity, float loadFactor)
// 包含“子Map”的构造函数
public Hashtable(Map t)Hashtable的API
synchronized void clear()
synchronized Object clone()
boolean contains(Object value)
synchronized boolean containsKey(Object key)
synchronized boolean containsValue(Object value)
synchronized Enumeration elements()
synchronized Set> entrySet()
synchronized boolean equals(Object object)
synchronized V get(Object key)
synchronized int hashCode()
synchronized boolean isEmpty()
synchronized Set keySet()
synchronized Enumeration keys()
synchronized V put(K key, V value)
synchronized void putAll(Map map)
synchronized V remove(Object key)
synchronized int size()
synchronized String toString()
synchronized Collection values() Hashtable源码解析(基于JDK1.6.0_45)
http://www.cnblogs.com/skywang12345/p/3310887.html
Hashtable实现的Cloneable接口
Hashtable实现了Cloneable接口，即实现了clone()方法。
clone()方法的作用很简单，就是克隆一个Hashtable对象并返回。
Hashtable实现的Serializable接口
Hashtable实现java.io.Serializable，分别实现了串行读取、写入功能。
串行写入函数就是将Hashtable的“总的容量，实际容量，所有的Entry”都写入到输出流中
串行读取函数：根据写入方式读出将Hashtable的“总的容量，实际容量，所有的Entry”依次读出
Hashtable遍历方式
1 遍历Hashtable的键值对
第一步：根据entrySet()获取Hashtable的“键值对”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。
// 假设table是Hashtable对象
// table中的key是String类型，value是Integer类型
Integer integ = null;
Iterator iter = table.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
// 获取key
key = (String)entry.getKey();
// 获取value
integ = (Integer)entry.getValue();
}2 通过Iterator遍历Hashtable的键
第一步：根据keySet()获取Hashtable的“键”的Set集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。
// 假设table是Hashtable对象
// table中的key是String类型，value是Integer类型
String key = null;
Integer integ = null;
Iterator iter = table.keySet().iterator();
while (iter.hasNext()) {
// 获取key
key = (String)iter.next();
// 根据key，获取value
integ = (Integer)table.get(key);
}4.3 通过Iterator遍历Hashtable的值
第一步：根据value()获取Hashtable的“值”的集合。
第二步：通过Iterator迭代器遍历“第一步”得到的集合。
// 假设table是Hashtable对象
// table中的key是String类型，value是Integer类型
Integer value = null;
Collection c = table.values();
Iterator iter= c.iterator();
while (iter.hasNext()) {
value = (Integer)iter.next();
}4.4 通过Enumeration遍历Hashtable的键
第一步：根据keys()获取Hashtable的集合。
第二步：通过Enumeration遍历“第一步”得到的集合。
while(enu.hasMoreElements()) {
System.out.println(enu.nextElement());
}
4.5 通过Enumeration遍历Hashtable的值
第一步：根据elements()获取Hashtable的集合。
第二步：通过Enumeration遍历“第一步”得到的集合。
Enumeration enu = table.elements();
while(enu.hasMoreElements()) {
System.out.println(enu.nextElement());
}Hashtable示例
public class Test {
public static void main(String[] args) {
testHashtableAPIs();
}
private static void testHashtableAPIs() {
// 初始化随机种子
Random r = new Random();
// 新建Hashtable
Hashtable table = new Hashtable();
// 添加操作
table.put("one", r.nextInt(10));
table.put("two", r.nextInt(10));
table.put("three", r.nextInt(10));
// 打印出table
System.out.println("table:"+table );
// 通过Iterator遍历key-value
Iterator iter = table.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
System.out.println( entry.getKey() +" : "+entry.getValue());
}
// Hashtable的键值对个数
System.out.println("size:"+table.size());
// containsKey(Object key) :是否包含键key
System.out.println("contains key two : "+table.containsKey("two"));
System.out.println("contains key five : "+table.containsKey("five"));
// containsValue(Object value) :是否包含值value
System.out.println("contains value 0 : "+table.containsValue(new Integer(0)));
// remove(Object key) ： 删除键key对应的键值对
table.remove("three");
System.out.println("table:"+table );
// clear() ： 清空Hashtable
table.clear();
// isEmpty() : Hashtable是否为空
System.out.println((table.isEmpty()?"table is empty":"table is not empty") );
}
}
/*
输出：
table:{two=5, one=6, three=9}
two : 5
one : 6
three : 9
size:3
contains key two : true
contains key five : false
contains value 0 : false
table:{two=5, one=6}
table is empty
*/TreeMap
TreeMap 简介
TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。
TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。
TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。
TreeMap 实现了Cloneable接口，意味着它能被克隆。
TreeMap 实现了java.io.Serializable接口，意味着它支持序列化。
TreeMap基于红黑树（Red-Black tree）实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
TreeMap的基本操作 containsKey、get、put 和 remove 的时间复杂度是 log(n) 。
另外，TreeMap是非同步的。 它的iterator 方法返回的迭代器是fail-fastl的。
TreeMap数据结构
TreeMap的继承关系
java.lang.Object
↳ java.util.AbstractMap
↳ java.util.TreeMap
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable {} TreeMap与Map关系如下图：
从图中可以看出：
1. TreeMap实现继承于AbstractMap，并且实现了NavigableMap接口。
2. TreeMap的本质是R-B Tree(红黑树)，它包含几个重要的成员变量： root, size, comparator。
root 是红黑数的根节点。它是Entry类型，Entry是红黑数的节点，它包含了红黑数的6个基本组成成分：key(键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜色)。Entry节点根据key进行排序，Entry节点包含的内容为value。
size是红黑数中节点的个数。
红黑树(一)之 原理和算法详细介绍http://www.cnblogs.com/skywang12345/p/3245399.html
TreeMap的构造函数
// 默认构造函数。使用该构造函数，TreeMap中的元素按照自然排序进行排列。
TreeMap()
// 创建的TreeMap包含Map
TreeMap(Mapextends K, ? extends V> copyFrom)
// 指定Tree的比较器
TreeMap(Comparatorsuper K> comparator)
// 创建的TreeSet包含copyFrom
TreeMap(SortedMapextends V> copyFrom) TreeMap的API
Entry<K, V> ceilingEntry(K key)
K ceilingKey(K key)
void clear()
Object clone()
ComparatorK> comparator()
boolean containsKey(Object key)
NavigableSet<K> descendingKeySet()
NavigableMap<K, V> descendingMap()
SetK, V>> entrySet()
Entry<K, V> firstEntry()
K firstKey()
Entry<K, V> floorEntry(K key)
K floorKey(K key)
V get(Object key)
NavigableMap<K, V> headMap(K to, boolean inclusive)
SortedMap<K, V> headMap(K toExclusive)
Entry<K, V> higherEntry(K key)
K higherKey(K key)
boolean isEmpty()
Set<K> keySet()
Entry<K, V> lastEntry()
K lastKey()
Entry<K, V> lowerEntry(K key)
K lowerKey(K key)
NavigableSet<K> navigableKeySet()
Entry<K, V> pollFirstEntry()
Entry<K, V> pollLastEntry()
V put(K key, V value)
V remove(Object key)
int size()
SortedMap<K, V> subMap(K fromInclusive, K toExclusive)
NavigableMap<K, V> subMap(K from, boolean fromInclusive, K to, boolean toInclusive)
NavigableMap<K, V> tailMap(K from, boolean inclusive)
SortedMap<K, V> tailMap(K fromInclusive) TreeMap源码解析
为了更了解TreeMap的原理，下面对TreeMap源码代码作出分析。我们先给出源码内容，后面再对源码进行详细说明，当然，源码内容中也包含了详细的代码注释。读者阅读的时候，建议先看后面的说明，先建立一个整体印象；之后再阅读源码。
package java.util;
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable
{
// 比较器。用来给TreeMap排序
private final Comparatorsuper K> comparator;
// TreeMap是红黑树实现的，root是红黑书的根节点
private transient Entry root = null;
// 红黑树的节点总数
private transient int size = 0;
// 记录红黑树的修改次数
private transient int modCount = 0;
// 默认构造函数
public TreeMap() {
comparator = null;
}
// 带比较器的构造函数
public TreeMap(Comparatorsuper K> comparator) {
this.comparator = comparator;
}
// 带Map的构造函数，Map会成为TreeMap的子集
public TreeMap(Map m) {
comparator = null;
putAll(m);
}
// 带SortedMap的构造函数，SortedMap会成为TreeMap的子集
public TreeMap(SortedMap m) {
comparator = m.comparator();
try {
buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
}
public int size() {
return size;
}
// 返回TreeMap中是否保护“键(key)”
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
// 返回TreeMap中是否保护"值(value)"
public boolean containsValue(Object value) {
// getFirstEntry() 是返回红黑树的第一个节点
// successor(e) 是获取节点e的后继节点
for (Entry e = getFirstEntry(); e != null; e = successor(e))
if (valEquals(value, e.value))
return true;
return false;
}
// 获取“键(key)”对应的“值(value)”
public V get(Object key) {
// 获取“键”为key的节点(p)
Entry p = getEntry(key);
// 若节点(p)为null，返回null；否则，返回节点对应的值
return (p==null ? null : p.value);
}
public Comparatorsuper K> comparator() {
return comparator;
}
// 获取第一个节点对应的key
public K firstKey() {
return key(getFirstEntry());
}
// 获取最后一个节点对应的key
public K lastKey() {
return key(getLastEntry());
}
// 将map中的全部节点添加到TreeMap中
public void putAll(Map map) {
// 获取map的大小
int mapSize = map.size();
// 如果TreeMap的大小是0,且map的大小不是0,且map是已排序的“key-value对”
if (size==0 && mapSize!=0 && map instanceof SortedMap) {
Comparator c = ((SortedMap)map).comparator();
// 如果TreeMap和map的比较器相等；
// 则将map的元素全部拷贝到TreeMap中，然后返回！
if (c == comparator || (c != null && c.equals(comparator))) {
++modCount;
try {
buildFromSorted(mapSize, map.entrySet().iterator(),
null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
return;
}
}
// 调用AbstractMap中的putAll();
// AbstractMap中的putAll()又会调用到TreeMap的put()
super.putAll(map);
}
// 获取TreeMap中“键”为key的节点
final Entry getEntry(Object key) {
// 若“比较器”为null，则通过getEntryUsingComparator()获取“键”为key的节点
if (comparator != null)
return getEntryUsingComparator(key);
if (key == null)
throw new NullPointerException();
Comparablesuper K> k = (Comparablesuper K>) key;
// 将p设为根节点
Entry p = root;
while (p != null) {
int cmp = k.compareTo(p.key);
// 若“p的key” < key，则p=“p的左孩子”
if (cmp < 0)
p = p.left;
// 若“p的key” > key，则p=“p的左孩子”
else if (cmp > 0)
p = p.right;
// 若“p的key” = key，则返回节点p
else
return p;
}
return null;
}
// 获取TreeMap中“键”为key的节点(对应TreeMap的比较器不是null的情况)
final Entry getEntryUsingComparator(Object key) {
K k = (K) key;
Comparatorsuper K> cpr = comparator;
if (cpr != null) {
// 将p设为根节点
Entry p = root;
while (p != null) {
int cmp = cpr.compare(k, p.key);
// 若“p的key” < key，则p=“p的左孩子”
if (cmp < 0)
p = p.left;
// 若“p的key” > key，则p=“p的左孩子”
else if (cmp > 0)
p = p.right;
// 若“p的key” = key，则返回节点p
else
return p;
}
}
return null;
}
// 获取TreeMap中不小于key的最小的节点；
// 若不存在(即TreeMap中所有节点的键都比key大)，就返回null
final Entry getCeilingEntry(K key) {
Entry p = root;
while (p != null) {
int cmp = compare(key, p.key);
// 情况一：若“p的key” > key。
// 若 p 存在左孩子，则设 p=“p的左孩子”；
// 否则，返回p
if (cmp < 0) {
if (p.left != null)
p = p.left;
else
return p;
// 情况二：若“p的key” < key。
} else if (cmp > 0) {
// 若 p 存在右孩子，则设 p=“p的右孩子”
if (p.right != null) {
p = p.right;
} else {
// 若 p 不存在右孩子，则找出 p 的后继节点，并返回
// 注意：这里返回的 “p的后继节点”有2种可能性：第一，null；第二，TreeMap中大于key的最小的节点。
// 理解这一点的核心是，getCeilingEntry是从root开始遍历的。
// 若getCeilingEntry能走到这一步，那么，它之前“已经遍历过的节点的key”都 > key。
// 能理解上面所说的，那么就很容易明白，为什么“p的后继节点”又2种可能性了。
Entry parent = p.parent;
Entry ch = p;
while (parent != null && ch == parent.right) {
ch = parent;
parent = parent.parent;
}
return parent;
}
// 情况三：若“p的key” = key。
} else
return p;
}
return null;
}
// 获取TreeMap中不大于key的最大的节点；
// 若不存在(即TreeMap中所有节点的键都比key小)，就返回null
// getFloorEntry的原理和getCeilingEntry类似，这里不再多说。
final Entry getFloorEntry(K key) {
Entry p = root;
while (p != null) {
int cmp = compare(key, p.key);
if (cmp > 0) {
if (p.right != null)
p = p.right;
else
return p;
} else if (cmp < 0) {
if (p.left != null) {
p = p.left;
} else {
Entry parent = p.parent;
Entry ch = p;
while (parent != null && ch == parent.left) {
ch = parent;
parent = parent.parent;
}
return parent;
}
} else
return p;
}
return null;
}
// 获取TreeMap中大于key的最小的节点。
// 若不存在，就返回null。
// 请参照getCeilingEntry来对getHigherEntry进行理解。
final Entry getHigherEntry(K key) {
Entry p = root;
while (p != null) {
int cmp = compare(key, p.key);
if (cmp < 0) {
if (p.left != null)
p = p.left;
else
return p;
} else {
if (p.right != null) {
p = p.right;
} else {
Entry parent = p.parent;
Entry ch = p;
while (parent != null && ch == parent.right) {
ch = parent;
parent = parent.parent;
}
return parent;
}
}
}
return null;
}
// 获取TreeMap中小于key的最大的节点。
// 若不存在，就返回null。
// 请参照getCeilingEntry来对getLowerEntry进行理解。
final Entry getLowerEntry(K key) {
Entry p = root;
while (p != null) {
int cmp = compare(key, p.key);
if (cmp > 0) {
if (p.right != null)
p = p.right;
else
return p;
} else {
if (p.left != null) {
p = p.left;
} else {
Entry parent = p.parent;
Entry ch = p;
while (parent != null && ch == parent.left) {
ch = parent;
parent = parent.parent;
}
return parent;
}
}
}
return null;
}
// 将“key, value”添加到TreeMap中
// 理解TreeMap的前提是掌握“红黑树”。
// 若理解“红黑树中添加节点”的算法，则很容易理解put。
public V put(K key, V value) {
Entry t = root;
// 若红黑树为空，则插入根节点
if (t == null) {
// TBD:
// 5045147: (coll) Adding null to an empty TreeSet should
// throw NullPointerException
//
// compare(key, key); // type check
root = new Entry(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry parent;
// split comparator and comparable paths
Comparatorsuper K> cpr = comparator;
// 在二叉树(红黑树是特殊的二叉树)中，找到(key, value)的插入位置。
// 红黑树是以key来进行排序的，所以这里以key来进行查找。
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();
Comparablesuper K> k = (Comparablesuper 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);
}
// 新建红黑树的节点(e)
Entry e = new Entry(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
// 红黑树插入节点后，不再是一颗红黑树；
// 这里通过fixAfterInsertion的处理，来恢复红黑树的特性。
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
// 删除TreeMap中的键为key的节点，并返回节点的值
public V remove(Object key) {
// 找到键为key的节点
Entry p = getEntry(key);
if (p == null)
return null;
// 保存节点的值
V oldValue = p.value;
// 删除节点
deleteEntry(p);
return oldValue;
}
// 清空红黑树
public void clear() {
modCount++;
size = 0;
root = null;
}
// 克隆一个TreeMap，并返回Object对象
public Object clone() {
TreeMap clone = null;
try {
clone = (TreeMap) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
// Put clone into "virgin" state (except for comparator)
clone.root = null;
clone.size = 0;
clone.modCount = 0;
clone.entrySet = null;
clone.navigableKeySet = null;
clone.descendingMap = null;
// Initialize clone with our mappings
try {
clone.buildFromSorted(size, entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
return clone;
}
// 获取第一个节点(对外接口)。
public Map.Entry firstEntry() {
return exportEntry(getFirstEntry());
}
// 获取最后一个节点(对外接口)。
public Map.Entry lastEntry() {
return exportEntry(getLastEntry());
}
// 获取第一个节点，并将改节点从TreeMap中删除。
public Map.Entry pollFirstEntry() {
// 获取第一个节点
Entry p = getFirstEntry();
Map.Entry result = exportEntry(p);
// 删除第一个节点
if (p != null)
deleteEntry(p);
return result;
}
// 获取最后一个节点，并将改节点从TreeMap中删除。
public Map.Entry pollLastEntry() {
// 获取最后一个节点
Entry p = getLastEntry();
Map.Entry result = exportEntry(p);
// 删除最后一个节点
if (p != null)
deleteEntry(p);
return result;
}
// 返回小于key的最大的键值对，没有的话返回null
public Map.Entry lowerEntry(K key) {
return exportEntry(getLowerEntry(key));
}
// 返回小于key的最大的键值对所对应的KEY，没有的话返回null
public K lowerKey(K key) {
return keyOrNull(getLowerEntry(key));
}
// 返回不大于key的最大的键值对，没有的话返回null
public Map.Entry floorEntry(K key) {
return exportEntry(getFloorEntry(key));
}
// 返回不大于key的最大的键值对所对应的KEY，没有的话返回null
public K floorKey(K key) {
return keyOrNull(getFloorEntry(key));
}
// 返回不小于key的最小的键值对，没有的话返回null
public Map.Entry ceilingEntry(K key) {
return exportEntry(getCeilingEntry(key));
}
// 返回不小于key的最小的键值对所对应的KEY，没有的话返回null
public K ceilingKey(K key) {
return keyOrNull(getCeilingEntry(key));
}
// 返回大于key的最小的键值对，没有的话返回null
public Map.Entry higherEntry(K key) {
return exportEntry(getHigherEntry(key));
}
// 返回大于key的最小的键值对所对应的KEY，没有的话返回null
public K higherKey(K key) {
return keyOrNull(getHigherEntry(key));
}
// TreeMap的红黑树节点对应的集合
private transient EntrySet entrySet = null;
// KeySet为KeySet导航类
private transient KeySet navigableKeySet = null;
// descendingMap为键值对的倒序“映射”
private transient NavigableMap descendingMap = null;
// 返回TreeMap的“键的集合”
public Set keySet() {
return navigableKeySet();
}
// 获取“可导航”的Key的集合
// 实际上是返回KeySet类的对象。
public NavigableSet navigableKeySet() {
KeySet nks = navigableKeySet;
return (nks != null) ? nks : (navigableKeySet = new KeySet(this));
}
// 返回“TreeMap的值对应的集合”
public Collection values() {
Collection vs = values;
return (vs != null) ? vs : (values = new Values());
}
// 获取TreeMap的Entry的集合，实际上是返回EntrySet类的对象。
public Set> entrySet() {
EntrySet es = entrySet;
return (es != null) ? es : (entrySet = new EntrySet());
}
// 获取TreeMap的降序Map
// 实际上是返回DescendingSubMap类的对象
public NavigableMap descendingMap() {
NavigableMap km = descendingMap;
return (km != null) ? km :
(descendingMap = new DescendingSubMap(this,
true, null, true,
true, null, true));
}
// 获取TreeMap的子Map
// 范围是从fromKey 到 toKey；fromInclusive是是否包含fromKey的标记，toInclusive是是否包含toKey的标记
public NavigableMap subMap(K fromKey, boolean fromInclusive,
K toKey, boolean toInclusive) {
return new AscendingSubMap(this,
false, fromKey, fromInclusive,
false, toKey, toInclusive);
}
// 获取“Map的头部”
// 范围从第一个节点 到 toKey, inclusive是是否包含toKey的标记
public NavigableMap headMap(K toKey, boolean inclusive) {
return new AscendingSubMap(this,
true, null, true,
false, toKey, inclusive);
}
// 获取“Map的尾部”。
// 范围是从 fromKey 到 最后一个节点，inclusive是是否包含fromKey的标记
public NavigableMap tailMap(K fromKey, boolean inclusive) {
return new AscendingSubMap(this,
false, fromKey, inclusive,
true, null, true);
}
// 获取“子Map”。
// 范围是从fromKey(包括) 到 toKey(不包括)
public SortedMap subMap(K fromKey, K toKey) {
return subMap(fromKey, true, toKey, false);
}
// 获取“Map的头部”。
// 范围从第一个节点 到 toKey(不包括)
public SortedMap headMap(K toKey) {
return headMap(toKey, false);
}
// 获取“Map的尾部”。
// 范围是从 fromKey(包括) 到 最后一个节点
public SortedMap tailMap(K fromKey) {
return tailMap(fromKey, true);
}
// ”TreeMap的值的集合“对应的类，它集成于AbstractCollection
class Values extends AbstractCollection<V> {
// 返回迭代器
public Iterator iterator() {
return new ValueIterator(getFirstEntry());
}
// 返回个数
public int size() {
return TreeMap.this.size();
}
// "TreeMap的值的集合"中是否包含"对象o"
public boolean contains(Object o) {
return TreeMap.this.containsValue(o);
}
// 删除"TreeMap的值的集合"中的"对象o"
public boolean remove(Object o) {
for (Entry e = getFirstEntry(); e != null; e = successor(e)) {
if (valEquals(e.getValue(), o)) {
deleteEntry(e);
return true;
}
}
return false;
}
// 清空删除"TreeMap的值的集合"
public void clear() {
TreeMap.this.clear();
}
}
// EntrySet是“TreeMap的所有键值对组成的集合”，
// EntrySet集合的单位是单个“键值对”。
class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator> iterator() {
return new EntryIterator(getFirstEntry());
}
// EntrySet中是否包含“键值对Object”
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry entry = (Map.Entry) o;
V value = entry.getValue();
Entry p = getEntry(entry.getKey());
return p != null && valEquals(p.getValue(), value);
}
// 删除EntrySet中的“键值对Object”
public boolean remove(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry entry = (Map.Entry) o;
V value = entry.getValue();
Entry p = getEntry(entry.getKey());
if (p != null && valEquals(p.getValue(), value)) {
deleteEntry(p);
return true;
}
return false;
}
// 返回EntrySet中元素个数
public int size() {
return TreeMap.this.size();
}
// 清空EntrySet
public void clear() {
TreeMap.this.clear();
}
}
// 返回“TreeMap的KEY组成的迭代器(顺序)”
Iterator keyIterator() {
return new KeyIterator(getFirstEntry());
}
// 返回“TreeMap的KEY组成的迭代器(逆序)”
Iterator descendingKeyIterator() {
return new DescendingKeyIterator(getLastEntry());
}
// KeySet是“TreeMap中所有的KEY组成的集合”
// KeySet继承于AbstractSet，而且实现了NavigableSet接口。
static final class KeySet<E> extends AbstractSet<E> implements NavigableSet<E> {
// NavigableMap成员，KeySet是通过NavigableMap实现的
private final NavigableMap m;
KeySet(NavigableMap map) { m = map; }
// 升序迭代器
public Iterator iterator() {
// 若是TreeMap对象，则调用TreeMap的迭代器keyIterator()
// 否则，调用TreeMap子类NavigableSubMap的迭代器keyIterator()
if (m instanceof TreeMap)
return ((TreeMap)m).keyIterator();
else
return (Iterator)(((TreeMap.NavigableSubMap)m).keyIterator());
}
// 降序迭代器
public Iterator descendingIterator() {
// 若是TreeMap对象，则调用TreeMap的迭代器descendingKeyIterator()
// 否则，调用TreeMap子类NavigableSubMap的迭代器descendingKeyIterator()
if (m instanceof TreeMap)
return ((TreeMap)m).descendingKeyIterator();
else
return (Iterator)(((TreeMap.NavigableSubMap)m).descendingKeyIterator());
}
public int size() { return m.size(); }
public boolean isEmpty() { return m.isEmpty(); }
public boolean contains(Object o) { return m.containsKey(o); }
public void clear() { m.clear(); }
public E lower(E e) { return m.lowerKey(e); }
public E floor(E e) { return m.floorKey(e); }
public E ceiling(E e) { return m.ceilingKey(e); }
public E higher(E e) { return m.higherKey(e); }
public E first() { return m.firstKey(); }
public E last() { return m.lastKey(); }
public Comparatorsuper E> comparator() { return m.comparator(); }
public E pollFirst() {
Map.Entry e = m.pollFirstEntry();
return e == null? null : e.getKey();
}
public E pollLast() {
Map.Entry e = m.pollLastEntry();
return e == null? null : e.getKey();
}
public boolean remove(Object o) {
int oldSize = size();
m.remove(o);
return size() != oldSize;
}
public NavigableSet subSet(E fromElement, boolean fromInclusive,
E toElement, boolean toInclusive) {
return new TreeSet(m.subMap(fromElement, fromInclusive,
toElement, toInclusive));
}
public NavigableSet headSet(E toElement, boolean inclusive) {
return new TreeSet(m.headMap(toElement, inclusive));
}
public NavigableSet tailSet(E fromElement, boolean inclusive) {
return new TreeSet(m.tailMap(fromElement, inclusive));
}
public SortedSet subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}
public SortedSet headSet(E toElement) {
return headSet(toElement, false);
}
public SortedSet tailSet(E fromElement) {
return tailSet(fromElement, true);
}
public NavigableSet descendingSet() {
return new TreeSet(m.descendingMap());
}
}
// 它是TreeMap中的一个抽象迭代器，实现了一些通用的接口。
abstract class PrivateEntryIterator<T> implements Iterator<T> {
// 下一个元素
Entry next;
// 上一次返回元素
Entry lastReturned;
// 期望的修改次数，用于实现fast-fail机制
int expectedModCount;
PrivateEntryIterator(Entry first) {
expectedModCount = modCount;
lastReturned = null;
next = first;
}
public final boolean hasNext() {
return next != null;
}
// 获取下一个节点
final Entry nextEntry() {
Entry e = next;
if (e == null)
throw new NoSuchElementException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
next = successor(e);
lastReturned = e;
return e;
}
// 获取上一个节点
final Entry prevEntry() {
Entry e = next;
if (e == null)
throw new NoSuchElementException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
next = predecessor(e);
lastReturned = e;
return e;
}
// 删除当前节点
public void remove() {
if (lastReturned == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
// 这里重点强调一下“为什么当lastReturned的左右孩子都不为空时，要将其赋值给next”。
// 目的是为了“删除lastReturned节点之后，next节点指向的仍然是下一个节点”。
// 根据“红黑树”的特性可知：
// 当被删除节点有两个儿子时。那么，首先把“它的后继节点的内容”复制给“该节点的内容”；之后，删除“它的后继节点”。
// 这意味着“当被删除节点有两个儿子时，删除当前节点之后，'新的当前节点'实际上是‘原有的后继节点(即下一个节点)’”。
// 而此时next仍然指向"新的当前节点"。也就是说next是仍然是指向下一个节点；能继续遍历红黑树。
if (lastReturned.left != null && lastReturned.right != null)
next = lastReturned;
deleteEntry(lastReturned);
expectedModCount = modCount;
lastReturned = null;
}
}
// TreeMap的Entry对应的迭代器
final class EntryIterator extends PrivateEntryIterator<Map.Entry<K,V>> {
EntryIterator(Entry first) {
super(first);
}
public Map.Entry next() {
return nextEntry();
}
}
// TreeMap的Value对应的迭代器
final class ValueIterator extends PrivateEntryIterator<V> {
ValueIterator(Entry first) {
super(first);
}
public V next() {
return nextEntry().value;
}
}
// reeMap的KEY组成的迭代器(顺序)
final class KeyIterator extends PrivateEntryIterator<K> {
KeyIterator(Entry first) {
super(first);
}
public K next() {
return nextEntry().key;
}
}
// TreeMap的KEY组成的迭代器(逆序)
final class DescendingKeyIterator extends PrivateEntryIterator<K> {
DescendingKeyIterator(Entry first) {
super(first);
}
public K next() {
return prevEntry().key;
}
}
// 比较两个对象的大小
final int compare(Object k1, Object k2) {
return comparator==null ? ((Comparablesuper K>)k1).compareTo((K)k2)
: comparator.compare((K)k1, (K)k2);
}
// 判断两个对象是否相等
final static boolean valEquals(Object o1, Object o2) {
return (o1==null ? o2==null : o1.equals(o2));
}
// 返回“Key-Value键值对”的一个简单拷贝(AbstractMap.SimpleImmutableEntry对象)
// 可用来读取“键值对”的值
static Map.Entry exportEntry(TreeMap.Entry e) {
return e == null? null :
new AbstractMap.SimpleImmutableEntry(e);
}
// 若“键值对”不为null，则返回KEY；否则，返回null
static K keyOrNull(TreeMap.Entry e) {
return e == null? null : e.key;
}
// 若“键值对”不为null，则返回KEY；否则，抛出异常
static K key(Entry e) {
if (e==null)
throw new NoSuchElementException();
return e.key;
}
// TreeMap的SubMap，它一个抽象类，实现了公共操作。
// 它包括了"(升序)AscendingSubMap"和"(降序)DescendingSubMap"两个子类。
static abstract class NavigableSubMap<K,V> extends AbstractMap<K,V>
implements NavigableMap<K,V>, java.io.Serializable {
// TreeMap的拷贝
final TreeMap m;
// lo是“子Map范围的最小值”，hi是“子Map范围的最大值”；
// loInclusive是“是否包含lo的标记”，hiInclusive是“是否包含hi的标记”
// fromStart是“表示是否从第一个节点开始计算”，
// toEnd是“表示是否计算到最后一个节点 ”
final K lo, hi;
final boolean fromStart, toEnd;
final boolean loInclusive, hiInclusive;
// 构造函数
NavigableSubMap(TreeMap m,
boolean fromStart, K lo, boolean loInclusive,
boolean toEnd, K hi, boolean hiInclusive) {
if (!fromStart && !toEnd) {
if (m.compare(lo, hi) > 0)
throw new IllegalArgumentException("fromKey > toKey");
} else {
if (!fromStart) // type check
m.compare(lo, lo);
if (!toEnd)
m.compare(hi, hi);
}
this.m = m;
this.fromStart = fromStart;
this.lo = lo;
this.loInclusive = loInclusive;
this.toEnd = toEnd;
this.hi = hi;
this.hiInclusive = hiInclusive;
}
// 判断key是否太小
final boolean tooLow(Object key) {
// 若该SubMap不包括“起始节点”，
// 并且，“key小于最小键(lo)”或者“key等于最小键(lo)，但最小键却没包括在该SubMap内”
// 则判断key太小。其余情况都不是太小！
if (!fromStart) {
int c = m.compare(key, lo);
if (c < 0 || (c == 0 && !loInclusive))
return true;
}
return false;
}
// 判断key是否太大
final boolean tooHigh(Object key) {
// 若该SubMap不包括“结束节点”，
// 并且，“key大于最大键(hi)”或者“key等于最大键(hi)，但最大键却没包括在该SubMap内”
// 则判断key太大。其余情况都不是太大！
if (!toEnd) {
int c = m.compare(key, hi);
if (c > 0 || (c == 0 && !hiInclusive))
return true;
}
return false;
}
// 判断key是否在“lo和hi”开区间范围内
final boolean inRange(Object key) {
return !tooLow(key) && !tooHigh(key);
}
// 判断key是否在封闭区间内
final boolean inClosedRange(Object key) {
return (fromStart || m.compare(key, lo) >= 0)
&& (toEnd || m.compare(hi, key) >= 0);
}
// 判断key是否在区间内, inclusive是区间开关标志
final boolean inRange(Object key, boolean inclusive) {
return inclusive ? inRange(key) : inClosedRange(key);
}
// 返回最低的Entry
final TreeMap.Entry absLowest() {
// 若“包含起始节点”，则调用getFirstEntry()返回第一个节点
// 否则的话，若包括lo，则调用getCeilingEntry(lo)获取大于/等于lo的最小的Entry;
// 否则，调用getHigherEntry(lo)获取大于lo的最小Entry
TreeMap.Entry e =
(fromStart ? m.getFirstEntry() :
(loInclusive ? m.getCeilingEntry(lo) :
m.getHigherEntry(lo)));
return (e == null || tooHigh(e.key)) ? null : e;
}
// 返回最高的Entry
final TreeMap.Entry absHighest() {
// 若“包含结束节点”，则调用getLastEntry()返回最后一个节点
// 否则的话，若包括hi，则调用getFloorEntry(hi)获取小于/等于hi的最大的Entry;
// 否则，调用getLowerEntry(hi)获取大于hi的最大Entry
TreeMap.Entry e =
TreeMap.Entry e =
(toEnd ? m.getLastEntry() :
(hiInclusive ? m.getFloorEntry(hi) :
m.getLowerEntry(hi)));
return (e == null || tooLow(e.key)) ? null : e;
}
// 返回"大于/等于key的最小的Entry"
final TreeMap.Entry absCeiling(K key) {
// 只有在“key太小”的情况下，absLowest()返回的Entry才是“大于/等于key的最小Entry”
// 其它情况下不行。例如，当包含“起始节点”时，absLowest()返回的是最小Entry了！
if (tooLow(key))
return absLowest();
// 获取“大于/等于key的最小Entry”
TreeMap.Entry e = m.getCeilingEntry(key);
return (e == null || tooHigh(e.key)) ? null : e;
}
// 返回"大于key的最小的Entry"
final TreeMap.Entry absHigher(K key) {
// 只有在“key太小”的情况下，absLowest()返回的Entry才是“大于key的最小Entry”
// 其它情况下不行。例如，当包含“起始节点”时，absLowest()返回的是最小Entry了,而不一定是“大于key的最小Entry”！
if (tooLow(key))
return absLowest();
// 获取“大于key的最小Entry”
TreeMap.Entry e = m.getHigherEntry(key);
return (e == null || tooHigh(e.key)) ? null : e;
}
// 返回"小于/等于key的最大的Entry"
final TreeMap.Entry absFloor(K key) {
// 只有在“key太大”的情况下，(absHighest)返回的Entry才是“小于/等于key的最大Entry”
// 其它情况下不行。例如，当包含“结束节点”时，absHighest()返回的是最大Entry了！
if (tooHigh(key))
return absHighest();
// 获取"小于/等于key的最大的Entry"
TreeMap.Entry e = m.getFloorEntry(key);
return (e == null || tooLow(e.key)) ? null : e;
}
// 返回"小于key的最大的Entry"
final TreeMap.Entry absLower(K key) {
// 只有在“key太大”的情况下，(absHighest)返回的Entry才是“小于key的最大Entry”
// 其它情况下不行。例如，当包含“结束节点”时，absHighest()返回的是最大Entry了,而不一定是“小于key的最大Entry”！
if (tooHigh(key))
return absHighest();
// 获取"小于key的最大的Entry"
TreeMap.Entry e = m.getLowerEntry(key);
return (e == null || tooLow(e.key)) ? null : e;
}
// 返回“大于最大节点中的最小节点”，不存在的话，返回null
final TreeMap.Entry absHighFence() {
return (toEnd ? null : (hiInclusive ?
m.getHigherEntry(hi) :
m.getCeilingEntry(hi)));
}
// 返回“小于最小节点中的最大节点”，不存在的话，返回null
final TreeMap.Entry absLowFence() {
return (fromStart ? null : (loInclusive ?
m.getLowerEntry(lo) :
m.getFloorEntry(lo)));
}
// 下面几个abstract方法是需要NavigableSubMap的实现类实现的方法
abstract TreeMap.Entry subLowest();
abstract TreeMap.Entry subHighest();
abstract TreeMap.Entry subCeiling(K key);
abstract TreeMap.Entry subHigher(K key);
abstract TreeMap.Entry subFloor(K key);
abstract TreeMap.Entry subLower(K key);
// 返回“顺序”的键迭代器
abstract Iterator keyIterator();
// 返回“逆序”的键迭代器
abstract Iterator descendingKeyIterator();
// 返回SubMap是否为空。空的话，返回true，否则返回false
public boolean isEmpty() {
return (fromStart && toEnd) ? m.isEmpty() : entrySet().isEmpty();
}
// 返回SubMap的大小
public int size() {
return (fromStart && toEnd) ? m.size() : entrySet().size();
}
// 返回SubMap是否包含键key
public final boolean containsKey(Object key) {
return inRange(key) && m.containsKey(key);
}
// 将key-value 插入SubMap中
public final V put(K key, V value) {
if (!inRange(key))
throw new IllegalArgumentException("key out of range");
return m.put(key, value);
}
// 获取key对应值
public final V get(Object key) {
return !inRange(key)? null : m.get(key);
}
// 删除key对应的键值对
public final V remove(Object key) {
return !inRange(key)? null : m.remove(key);
}
// 获取“大于/等于key的最小键值对”
public final Map.Entry ceilingEntry(K key) {
return exportEntry(subCeiling(key));
}
// 获取“大于/等于key的最小键”
public final K ceilingKey(K key) {
return keyOrNull(subCeiling(key));
}
// 获取“大于key的最小键值对”
public final Map.Entry higherEntry(K key) {
return exportEntry(subHigher(key));
}
// 获取“大于key的最小键”
public final K higherKey(K key) {
return keyOrNull(subHigher(key));
}
// 获取“小于/等于key的最大键值对”
public final Map.Entry floorEntry(K key) {
return exportEntry(subFloor(key));
}
// 获取“小于/等于key的最大键”
public final K floorKey(K key) {
return keyOrNull(subFloor(key));
}
// 获取“小于key的最大键值对”
public final Map.Entry lowerEntry(K key) {
return exportEntry(subLower(key));
}
// 获取“小于key的最大键”
public final K lowerKey(K key) {
return keyOrNull(subLower(key));
}
// 获取"SubMap的第一个键"
public final K firstKey() {
return key(subLowest());
}
// 获取"SubMap的最后一个键"
public final K lastKey() {
return key(subHighest());
}
// 获取"SubMap的第一个键值对"
public final Map.Entry firstEntry() {
return exportEntry(subLowest());
}
// 获取"SubMap的最后一个键值对"
public final Map.Entry lastEntry() {
return exportEntry(subHighest());
}
// 返回"SubMap的第一个键值对"，并从SubMap中删除改键值对
public final Map.Entry pollFirstEntry() {
TreeMap.Entry e = subLowest();
Map.Entry result = exportEntry(e);
if (e != null)
m.deleteEntry(e);
return result;
}
// 返回"SubMap的最后一个键值对"，并从SubMap中删除改键值对
public final Map.Entry pollLastEntry() {
TreeMap.Entry e = subHighest();
Map.Entry result = exportEntry(e);
if (e != null)
m.deleteEntry(e);
return result;
}
// Views
transient NavigableMap descendingMapView = null;
transient EntrySetView entrySetView = null;
transient KeySet navigableKeySetView = null;
// 返回NavigableSet对象，实际上返回的是当前对象的"Key集合"。
public final NavigableSet navigableKeySet() {
KeySet nksv = navigableKeySetView;
return (nksv != null) ? nksv :
(navigableKeySetView = new TreeMap.KeySet(this));
}
// 返回"Key集合"对象
public final Set keySet() {
return navigableKeySet();
}
// 返回“逆序”的Key集合
public NavigableSet descendingKeySet() {
return descendingMap().navigableKeySet();
}
// 排列fromKey(包含) 到 toKey(不包含) 的子map
public final SortedMap subMap(K fromKey, K toKey) {
return subMap(fromKey, true, toKey, false);
}
// 返回当前Map的头部(从第一个节点 到 toKey, 不包括toKey)
public final SortedMap headMap(K toKey) {
return headMap(toKey, false);
}
// 返回当前Map的尾部[从 fromKey(包括fromKeyKey) 到 最后一个节点]
public final SortedMap tailMap(K fromKey) {
return tailMap(fromKey, true);
}
// Map的Entry的集合
abstract class EntrySetView extends AbstractSet<Map.Entry<K,V>> {
private transient int size = -1, sizeModCount;
// 获取EntrySet的大小
public int size() {
// 若SubMap是从“开始节点”到“结尾节点”，则SubMap大小就是原TreeMap的大小
if (fromStart && toEnd)
return m.size();
// 若SubMap不是从“开始节点”到“结尾节点”，则调用iterator()遍历EntrySetView中的元素
if (size == -1 || sizeModCount != m.modCount) {
sizeModCount = m.modCount;
size = 0;
Iterator i = iterator();
while (i.hasNext()) {
size++;
i.next();
}
}
return size;
}
// 判断EntrySetView是否为空
public boolean isEmpty() {
TreeMap.Entry n = absLowest();
return n == null || tooHigh(n.key);
}
// 判断EntrySetView是否包含Object
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry entry = (Map.Entry) o;
K key = entry.getKey();
if (!inRange(key))
return false;
TreeMap.Entry node = m.getEntry(key);
return node != null &&
valEquals(node.getValue(), entry.getValue());
}
// 从EntrySetView中删除Object
public boolean remove(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry entry = (Map.Entry) o;
K key = entry.getKey();
if (!inRange(key))
return false;
TreeMap.Entry node = m.getEntry(key);
if (node!=null && valEquals(node.getValue(),entry.getValue())){
m.deleteEntry(node);
return true;
}
return false;
}
}
// SubMap的迭代器
abstract class SubMapIterator<T> implements Iterator<T> {
// 上一次被返回的Entry
TreeMap.Entry lastReturned;
// 指向下一个Entry
TreeMap.Entry next;
// “栅栏key”。根据SubMap是“升序”还是“降序”具有不同的意义
final K fenceKey;
int expectedModCount;
// 构造函数
SubMapIterator(TreeMap.Entry first,
TreeMap.Entry fence) {
// 每创建一个SubMapIterator时，保存修改次数
// 若后面发现expectedModCount和modCount不相等，则抛出ConcurrentModificationException异常。
// 这就是所说的fast-fail机制的原理！
expectedModCount = m.modCount;
lastReturned = null;
next = first;
fenceKey = fence == null ? null : fence.key;
}
// 是否存在下一个Entry
public final boolean hasNext() {
return next != null && next.key != fenceKey;
}
// 返回下一个Entry
final TreeMap.Entry nextEntry() {
TreeMap.Entry e = next;
if (e == null || e.key == fenceKey)
throw new NoSuchElementException();
if (m.modCount != expectedModCount)
throw new ConcurrentModificationException();
// next指向e的后继节点
next = successor(e);
lastReturned = e;
return e;
}
// 返回上一个Entry
final TreeMap.Entry prevEntry() {
TreeMap.Entry e = next;
if (e == null || e.key == fenceKey)
throw new NoSuchElementException();
if (m.modCount != expectedModCount)
throw new ConcurrentModificationException();
// next指向e的前继节点
next = predecessor(e);
lastReturned = e;
return e;
}
// 删除当前节点(用于“升序的SubMap”)。
// 删除之后，可以继续升序遍历；红黑树特性没变。
final void removeAscending() {
if (lastReturned == null)
throw new IllegalStateException();
if (m.modCount != expectedModCount)
throw new ConcurrentModificationException();
// 这里重点强调一下“为什么当lastReturned的左右孩子都不为空时，要将其赋值给next”。
// 目的是为了“删除lastReturned节点之后，next节点指向的仍然是下一个节点”。
// 根据“红黑树”的特性可知：
// 当被删除节点有两个儿子时。那么，首先把“它的后继节点的内容”复制给“该节点的内容”；之后，删除“它的后继节点”。
// 这意味着“当被删除节点有两个儿子时，删除当前节点之后，'新的当前节点'实际上是‘原有的后继节点(即下一个节点)’”。
// 而此时next仍然指向"新的当前节点"。也就是说next是仍然是指向下一个节点；能继续遍历红黑树。
if (lastReturned.left != null && lastReturned.right != null)
next = lastReturned;
m.deleteEntry(lastReturned);
lastReturned = null;
expectedModCount = m.modCount;
}
// 删除当前节点(用于“降序的SubMap”)。
// 删除之后，可以继续降序遍历；红黑树特性没变。
final void removeDescending() {
if (lastReturned == null)
throw new IllegalStateException();
if (m.modCount != expectedModCount)
throw new ConcurrentModificationException();
m.deleteEntry(lastReturned);
lastReturned = null;
expectedModCount = m.modCount;
}
}
// SubMap的Entry迭代器，它只支持升序操作，继承于SubMapIterator
final class SubMapEntryIterator extends SubMapIterator<Map.Entry<K,V>> {
SubMapEntryIterator(TreeMap.Entry first,
TreeMap.Entry fence) {
super(first, fence);
}
// 获取下一个节点(升序)
public Map.Entry next() {
return nextEntry();
}
// 删除当前节点(升序)
public void remove() {
removeAscending();
}
}
// SubMap的Key迭代器，它只支持升序操作，继承于SubMapIterator
final class SubMapKeyIterator extends SubMapIterator<K> {
SubMapKeyIterator(TreeMap.Entry first,
TreeMap.Entry fence) {
super(first, fence);
}
// 获取下一个节点(升序)
public K next() {
return nextEntry().key;
}
// 删除当前节点(升序)
public void remove() {
removeAscending();
}
}
// 降序SubMap的Entry迭代器，它只支持降序操作，继承于SubMapIterator
final class DescendingSubMapEntryIterator extends SubMapIterator<Map.Entry<K,V>> {
DescendingSubMapEntryIterator(TreeMap.Entry last,
TreeMap.Entry fence) {
super(last, fence);
}
// 获取下一个节点(降序)
public Map.Entry next() {
return prevEntry();
}
// 删除当前节点(降序)
public void remove() {
removeDescending();
}
}
// 降序SubMap的Key迭代器，它只支持降序操作，继承于SubMapIterator
final class DescendingSubMapKeyIterator extends SubMapIterator<K> {
DescendingSubMapKeyIterator(TreeMap.Entry last,
TreeMap.Entry fence) {
super(last, fence);
}
// 获取下一个节点(降序)
public K next() {
return prevEntry().key;
}
// 删除当前节点(降序)
public void remove() {
removeDescending();
}
}
}
// 升序的SubMap，继承于NavigableSubMap
static final class AscendingSubMap<K,V> extends NavigableSubMap<K,V> {
private static final long serialVersionUID = 912986545866124060L;
// 构造函数
AscendingSubMap(TreeMap m,
boolean fromStart, K lo, boolean loInclusive,
boolean toEnd, K hi, boolean hiInclusive) {
super(m, fromStart, lo, loInclusive, toEnd, hi, hiInclusive);
}
// 比较器
public Comparatorsuper K> comparator() {
return m.comparator();
}
// 获取“子Map”。
// 范围是从fromKey 到 toKey；fromInclusive是是否包含fromKey的标记，toInclusive是是否包含toKey的标记
public NavigableMap subMap(K fromKey, boolean fromInclusive,
K toKey, boolean toInclusive) {
if (!inRange(fromKey, fromInclusive))
throw new IllegalArgumentException("fromKey out of range");
if (!inRange(toKey, toInclusive))
throw new IllegalArgumentException("toKey out of range");
return new AscendingSubMap(m,
false, fromKey, fromInclusive,
false, toKey, toInclusive);
}
// 获取“Map的头部”。
// 范围从第一个节点 到 toKey, inclusive是是否包含toKey的标记
public NavigableMap headMap(K toKey, boolean inclusive) {
if (!inRange(toKey, inclusive))
throw new IllegalArgumentException("toKey out of range");
return new AscendingSubMap(m,
fromStart, lo, loInclusive,
false, toKey, inclusive);
}
// 获取“Map的尾部”。
// 范围是从 fromKey 到 最后一个节点，inclusive是是否包含fromKey的标记
public NavigableMap tailMap(K fromKey, boolean inclusive){
if (!inRange(fromKey, inclusive))
throw new IllegalArgumentException("fromKey out of range");
return new AscendingSubMap(m,
false, fromKey, inclusive,
toEnd, hi, hiInclusive);
}
// 获取对应的降序Map
public NavigableMap descendingMap() {
NavigableMap mv = descendingMapView;
return (mv != null) ? mv :
(descendingMapView =
new DescendingSubMap(m,
fromStart, lo, loInclusive,
toEnd, hi, hiInclusive));
}
// 返回“升序Key迭代器”
Iterator keyIterator() {
return new SubMapKeyIterator(absLowest(), absHighFence());
}
// 返回“降序Key迭代器”
Iterator descendingKeyIterator() {
return new DescendingSubMapKeyIterator(absHighest(), absLowFence());
}
// “升序EntrySet集合”类
// 实现了iterator()
final class AscendingEntrySetView extends EntrySetView {
public Iterator> iterator() {
return new SubMapEntryIterator(absLowest(), absHighFence());
}
}
// 返回“升序EntrySet集合”
public Set> entrySet() {
EntrySetView es = entrySetView;
return (es != null) ? es : new AscendingEntrySetView();
}
TreeMap.Entry subLowest() { return absLowest(); }
TreeMap.Entry subHighest() { return absHighest(); }
TreeMap.Entry subCeiling(K key) { return absCeiling(key); }
TreeMap.Entry subHigher(K key) { return absHigher(key); }
TreeMap.Entry subFloor(K key) { return absFloor(key); }
TreeMap.Entry subLower(K key) { return absLower(key); }
}
// 降序的SubMap，继承于NavigableSubMap
// 相比于升序SubMap，它的实现机制是将“SubMap的比较器反转”！
static final class DescendingSubMap<K,V> extends NavigableSubMap<K,V> {
private static final long serialVersionUID = 912986545866120460L;
DescendingSubMap(TreeMap m,
boolean fromStart, K lo, boolean loInclusive,
boolean toEnd, K hi, boolean hiInclusive) {
super(m, fromStart, lo, loInclusive, toEnd, hi, hiInclusive);
}
// 反转的比较器：是将原始比较器反转得到的。
private final Comparatorsuper K> reverseComparator =
Collections.reverseOrder(m.comparator);
// 获取反转比较器
public Comparatorsuper K> comparator() {
return reverseComparator;
}
// 获取“子Map”。
// 范围是从fromKey 到 toKey；fromInclusive是是否包含fromKey的标记，toInclusive是是否包含toKey的标记
public NavigableMap subMap(K fromKey, boolean fromInclusive,
K toKey, boolean toInclusive) {
if (!inRange(fromKey, fromInclusive))
throw new IllegalArgumentException("fromKey out of range");
if (!inRange(toKey, toInclusive))
throw new IllegalArgumentException("toKey out of range");
return new DescendingSubMap(m,
false, toKey, toInclusive,
false, fromKey, fromInclusive);
}
// 获取“Map的头部”。
// 范围从第一个节点 到 toKey, inclusive是是否包含toKey的标记
public NavigableMap headMap(K toKey, boolean inclusive) {
if (!inRange(toKey, inclusive))
throw new IllegalArgumentException("toKey out of range");
return new DescendingSubMap(m,
false, toKey, inclusive,
toEnd, hi, hiInclusive);
}
// 获取“Map的尾部”。
// 范围是从 fromKey 到 最后一个节点，inclusive是是否包含fromKey的标记
public NavigableMap tailMap(K fromKey, boolean inclusive){
if (!inRange(fromKey, inclusive))
throw new IllegalArgumentException("fromKey out of range");
return new DescendingSubMap(m,
fromStart, lo, loInclusive,
false, fromKey, inclusive);
}
// 获取对应的降序Map
public NavigableMap descendingMap() {
NavigableMap mv = descendingMapView;
return (mv != null) ? mv :
(descendingMapView =
new AscendingSubMap(m,
fromStart, lo, loInclusive,
toEnd, hi, hiInclusive));
}
// 返回“升序Key迭代器”
Iterator keyIterator() {
return new DescendingSubMapKeyIterator(absHighest(), absLowFence());
}
// 返回“降序Key迭代器”
Iterator descendingKeyIterator() {
return new SubMapKeyIterator(absLowest(), absHighFence());
}
// “降序EntrySet集合”类
// 实现了iterator()
final class DescendingEntrySetView extends EntrySetView {
public Iterator> iterator() {
return new DescendingSubMapEntryIterator(absHighest(), absLowFence());
}
}
// 返回“降序EntrySet集合”
public Set> entrySet() {
EntrySetView es = entrySetView;
return (es != null) ? es : new DescendingEntrySetView();
}
TreeMap.Entry subLowest() { return absHighest(); }
TreeMap.Entry subHighest() { return absLowest(); }
TreeMap.Entry subCeiling(K key) { return absFloor(key); }
TreeMap.Entry subHigher(K key) { return absLower(key); }
TreeMap.Entry subFloor(K key) { return absCeiling(key); }
TreeMap.Entry subLower(K key) { return absHigher(key); }
}
// SubMap是旧版本的类，新的Java中没有用到。
private class SubMap extends AbstractMap<K,V>
implements SortedMap<K,V>, java.io.Serializable {
private static final long serialVersionUID = -6520786458950516097L;
private boolean fromStart = false, toEnd = false;
private K fromKey, toKey;
private Object readResolve() {
return new AscendingSubMap(TreeMap.this,
fromStart, fromKey, true,
toEnd, toKey, false);
}
public Set> entrySet() { throw new InternalError(); }
public K lastKey() { throw new InternalError(); }
public K firstKey() { throw new InternalError(); }
public SortedMap subMap(K fromKey, K toKey) { throw new InternalError(); }
public SortedMap headMap(K toKey) { throw new InternalError(); }
public SortedMap tailMap(K fromKey) { throw new InternalError(); }
public Comparatorsuper K> comparator() { throw new InternalError(); }
}
// 红黑树的节点颜色--红色
private static final boolean RED = false;
// 红黑树的节点颜色--黑色
private static final boolean BLACK = true;
// “红黑树的节点”对应的类。
// 包含了 key(键)、value(值)、left(左孩子)、right(右孩子)、parent(父节点)、color(颜色)
static final class Entry<K,V> implements Map.Entry<K,V> {
// 键
K key;
// 值
V value;
// 左孩子
Entry left = null;
// 右孩子
Entry right = null;
// 父节点
Entry parent;
// 当前节点颜色
boolean color = BLACK;
// 构造函数
Entry(K key, V value, Entry parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
// 返回“键”
public K getKey() {
return key;
}
// 返回“值”
public V getValue() {
return value;
}
// 更新“值”，返回旧的值
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
// 判断两个节点是否相等的函数，覆盖equals()函数。
// 若两个节点的“key相等”并且“value相等”，则两个节点相等
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
}
// 覆盖hashCode函数。
public int hashCode() {
int keyHash = (key==null ? 0 : key.hashCode());
int valueHash = (value==null ? 0 : value.hashCode());
return keyHash ^ valueHash;
}
// 覆盖toString()函数。
public String toString() {
return key + "=" + value;
}
}
// 返回“红黑树的第一个节点”
final Entry getFirstEntry() {
Entry p = root;
if (p != null)
while (p.left != null)
p = p.left;
return p;
}
// 返回“红黑树的最后一个节点”
final Entry getLastEntry() {
Entry p = root;
if (p != null)
while (p.right != null)
p = p.right;
return p;
}
// 返回“节点t的后继节点”
static TreeMap.Entry successor(Entry t) {
if (t == null)
return null;
else if (t.right != null) {
Entry p = t.right;
while (p.left != null)
p = p.left;
return p;
} else {
Entry p = t.parent;
Entry ch = t;
while (p != null && ch == p.right) {
ch = p;
p = p.parent;
}
return p;
}
}
// 返回“节点t的前继节点”
static Entry predecessor(Entry t) {
if (t == null)
return null;
else if (t.left != null) {
Entry p = t.left;
while (p.right != null)
p = p.right;
return p;
} else {
Entry p = t.parent;
Entry ch = t;
while (p != null && ch == p.left) {
ch = p;
p = p.parent;
}
return p;
}
}
// 返回“节点p的颜色”
// 根据“红黑树的特性”可知：空节点颜色是黑色。
private static boolean colorOf(Entry p) {
return (p == null ? BLACK : p.color);
}
// 返回“节点p的父节点”
private static Entry parentOf(Entry p) {
return (p == null ? null: p.parent);
}
// 设置“节点p的颜色为c”
private static