Java Map详解 底层原理

原文地址

Map详解 底层原理

Map

An object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value.
将键映射到值的对象。映射不能包含重复的键; 每个键最多可以映射到一个值。

public interface Map<K,V>
并没有继承Collection接口

Map主要函数

	int size();
	boolean isEmpty();
	boolean containsKey(Object key);
	boolean containsValue(Object value);
	V get(Object key);
	V remove(Object key);
	void putAll(Map<? extends K, ? extends V> m);
	void clear();
	Set<K> keySet();
	Collection<V> values();
	//返回Map中所包含的键值所对应的Set集合
	Set<Map.Entry<K, V>> entrySet();
	//内部的Entry，每个集合的元素都是Entry对象
	K getKey();//返回Entry的Key值
	V getValue();//返回Entry的value值
	V setValue(V value);//设置Entry的value值

Map中主要的实现类

一、HashMap

	public class HashMap<K,V> extends AbstractMap<K,V>
	implements Map<K,V>, Cloneable, Serializable
	//默认内存大小，必须是2的幂
	static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
	//最大内存
	static final int MAXIMUM_CAPACITY = 1 << 30;
	//哈希节点
	static class Node<K,V> implements Map.Entry<K,V> {
	final int hash;
	final K key;
	V value;
	Node<K,V> next;
	}
	// 计算key的hash值
	static final int hash(Object key) {
	int h;
	return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
	}
	//hash表
	transient Node<K,V>[] table;
	//通过计算hash值来来比较key
	//过去value
	public V get(Object key) {
	Node<K,V> e;
	return (e = getNode(hash(key), key)) == null ? null : e.value;
	}
	//获取流程：
	//根据hash值获取hash表中对应的值
	//--如果first.key是否也key对应。对应则返回
	//--如果不同则存在hash冲突
	//----因为1.8之后加入红黑树，hash冲突先判断是否已经转化为红黑树，否则还是链表的形式，查找到返回即可。
	inal 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;
	}
	//重点关注 添加值
	// 先查找hash是否存在，不存在直接添加进表即可
	//-存在，则判断是否key是否已经存在了
	//---判断是否转化为了红黑树，是 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
	//-----不是红黑树，链表查询，查找不到就插入链表中，如果查找binCount >= TREEIFY_THRESHOLD - 1次转化为红黑树。
	static final int TREEIFY_THRESHOLD = 8;
	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;
	}
	//链表转化为红黑树
	//前提 (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)，hashtable长度大于64
	static final int MIN_TREEIFY_CAPACITY = 64;
	final void treeifyBin(Node<K,V>[] tab, int hash) {
	int n, index; Node<K,V> e;
	if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
	resize();
	else if ((e = tab[index = (n - 1) & hash]) != null) {
	TreeNode<K,V> hd = null, tl = null;
	do {
	TreeNode<K,V> p = replacementTreeNode(e, null);
	if (tl == null)
	hd = p;
	else {
	p.prev = tl;
	tl.next = p;
	}
	tl = p;
	} while ((e = e.next) != null);
	if ((tab[index] = hd) != null)
	hd.treeify(tab);
	}
	}
	//红黑树还不会，其他的就没看；

总结

HashMap 是非线程安全的。基于HashMap实现的，键值需要明确定义hashcode和equals，如果不重写的话，存在两个对象，equals相等，却hashcode不同。就可能出现问题了。因为是根据先hashcode查找，再根据equals查找的。
底层是hashtable，即数组加链表，当冲突长度>8并且hashtable长度>64转化为将链表转化为红黑树。

二、Hashtable

This class implements a hash table, which maps keys to values. Any non-null object can be used as a key or as a value.
这个类实现了一个哈希表，它将键映射到值。任何非空对象都可以用作键或值。
线程安全

	//底层还是hash表
	private transient Entry<?,?>[] table;
	//多了是否包含值
	public synchronized boolean contains(Object value){
	if (e.value.equals(value))//底层是equals
	}

总结

一些方法加了synchronized修饰，线程安全的，查询效率较低，去掉了HashTable的contains方法，但是加上了containsValue()和containsKey()方法。需要重写hashCode()和equals()。底层还是哈希表

TreeMap

A Red-Black tree based NavigableMap implementation. The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time, depending on which constructor is used.
一种基于红黑树的NavigableMap实现的。根据其键的自然顺序或在map创建时提供的比较器对map进行排序，具体取决于使用哪种构造函数。

	//树根
	private transient Entry<K,V> root;
	//二叉树
	static final class Entry<K,V> implements Map.Entry<K,V> {
	K key;
	V value;
	Entry<K,V> left;
	Entry<K,V> right;
	Entry<K,V> parent;
	boolean color = BLACK;
	}
	//一切获取比较，都是根据Comparable接口的方法来实现的，相同就覆盖，不同就插入
	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);
	}
	public K firstKey();//最小的键
	public K lastKey();//最大的键
	final Entry<K,V> getFirstEntry();//最小的键对
	final Entry<K,V> getLastEntry() ;//最大的键对
	final Entry<K,V> getLowerEntry(K key);//位于key前一维的键值对
	final Entry<K,V> getHigherEntry(K key) ;//位于key后一维的键值对
	//其他看不懂。

总结

适用于按自然顺序或自定义顺序遍历键(key)。两种方式排序：自然排序和比较器排序。

总结

HashMap和HashTable需要重写hashcode和equals方法，HashTable线程安全，而HashMap是非同步的，效率上比HashTable要高，HashMap允许空键值，而HashTable不允许。
Treemap可以自定义排序规则。