标签：color 工作原理 dea 哈希 jdk 阈值 直接 继承 move
一、HashMap简介
HashMap是一种基于数组+链表+红黑树的数据结构，其中红黑树部分在JDK1.8后引入，当链表长度大于8的时候转换为红黑树。
HashMap继承于AbstractMap（Map的骨架实现类），实现Map接口。
HashMap因为采用hashCode的值存储，所以性能一般情况下为O（1）。
HashMap最多只允许一条记录的键为null，允许多条记录的值为null。
HashMap线程不安全，如在多线程环境下可以使用Collections工具类将其转换为线程安全，也可使用JDK提供的CocurrentHashMap，不建议使用HashTable，理由是并发性能一般。
二、HashMap存储结构分析
HashMap用哈希表存储元素，其中采用链地址法解决冲突。
Node<K,V>是HashMap的内部实现类，实现Map.Entry<K,V>。
源码为：
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; } }
再来看看HashMap其他的几个属性：
transient Node<K,V>[] table; //数组 transient int size; //实际存在键值对数 transient int modCount; //修改次数 int threshold; //所能容纳的key-value对极限 final float loadFactor; //负载因子 默认为0.75不建议修改
其中table默认的构造长度是16，并且要求length是2的n次方，这是一种非常规的设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap定位哈希桶索引位置时，也加入了高位参与运算的过程。
当数据量增大后，即便负载因子和Hash算法设计的再合理，也避免不了链表长度增加，如此一来就会影响HashMap的性能，所以JDK1.8开始引入了红黑树，利用红黑树高性能的增删查改解决这一问题，这里不讨论红黑树。
三、HashMap的功能实现
1）构造HashMap
HashMap有四个构造函数：
以下就源码逐个分析构造函数
public HashMap(int initialCapacity, float loadFactor) { //构造时传入指定大小以及负载因子 if (initialCapacity < 0) //容量大小合法性判断 throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
//最大容量只能为MAXIMUM_CAPACTITY，2的30次方 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倍 }
public HashMap(int initialCapacity) { //指定容量大小，负载因子使用默认值0.75，调用上面的构造器 this(initialCapacity, DEFAULT_LOAD_FACTOR); }
public HashMap() { //无参构造器，设置负载因子为默认值 this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted }
public HashMap(Map<? extends K, ? extends V> m) { //包含子map的构造函数 this.loadFactor = DEFAULT_LOAD_FACTOR; //设置默认负载因子 putMapEntries(m, false); // 将传入的map元素逐个加入到HashMap中 }
2）确定数组索引位置
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
这是JDK1.8中确定数组索引的方法，h = key.hashCode() 为第一步 取hashCode值，h ^ (h >>> 16) 为第二步 高位参与运算，这里的Hash算法本质上就是三步：取key的hashCode值、高位运算、取模运算。
3）HashMap的put方法
首先是逻辑分析，put方法的处理逻辑：
①.判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；
②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③；
③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals；
④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤；
⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。
看源代码实现：
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i;
//tab为空则新建 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length;
//计算index，并处理null if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k;
//通过hashcode值以及equals方法判断key是否存在，是的话直接覆盖value 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);
//如果链表长度大于8转换为红黑树 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; }
//key已经存在直接覆盖value 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; }
4）扩容机制
Java中数组扩容是无法自动扩容的，方法是用新数组代替旧数组。融入了红黑树后，resize方法复杂度大大增加，这里简单说下1.7的处理的过程：
传入新的容量--引用扩容前的数组--判断是否达到最大容量--初始化新数组--复制数据--设置table属性引用新的数组--修改阈值
5）HashMap的get方法
HashMap存储元素是通过计算HashCode值确定精确索引存放的，但是不同的key是有可能出现有相同的HashCode值的，这时候他们会被存放在同一个桶中（bucket），
然后通过equals方法来确保key的唯一性。
因此当取出数据时，就要根据hash算法找到在数组的存储位置，再根据equals方法从该桶中找出对应的数据。
明白了逻辑以后看源代码实现：
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; 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; }
针对HashMap的学习主要理解它的存储结构，工作原理，工作原理可以通过put与get方法去理解，期间可能产生扩容；另外要明白hashcode和equals两个方法在HashMap中
的作用。此外还有一些常用的方法containsKey，clear，remove，可以查看源码学习。
标签：color 工作原理 dea 哈希 jdk 阈值 直接 继承 move
原文地址：http://www.cnblogs.com/sunlightcty/p/7478627.html
