HashMap源码分析

HashMap的实现通常是通过哈希表实现的，哈希表中有若干个桶。但是，当桶中数量太大时，将会转化为存放树结点的桶，每个树结点的结构与java.util.TreeMap类似。树桶的使用方式和一般桶的方式一样，但是在桶中容量过大的情况下，前者具有更快的查询效率。然而，一般情况下，正常的桶容量一般不会过大，所以检查树桶的操作可能会延迟。

PS：树桶（即存放树节点的桶）是按照哈希值的顺序存放内部节点的，但是如果两个结点有相同的class C implements Comparable，则会对这两个结点进行排序。在最坏的情况下，树桶中这样格外的开销是值得的，时间复杂度是O(log n)，但是当哈希表中的值过于分散或者一个树桶中有过量树节点时，将会导致性能下降，浪费时间和空间。（过量树节点会带来过量比较操作）。

由于树节点的大小是一般节点的两倍，所以当一个桶中有足够的节点以保证使用的时候，才可以使用数节点（可以设置TREEIFY_THRESHOLD），并且，当桶中节点数量变少（删除节点或重新定义容量）时，树节点将转化为一般节点。在一个均匀分布的哈希表中，树桶很少被使用。
一般情况下，树的根节点是它的第一个节点，但是特殊情况下可能不是，但是可以使用TreeNode.root()方法找到。

下面，我们看源码的具体实现

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {

由此可见，HashMap继承AbstractMap，实现了Map、Cloneable和Serializable 接口

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
static final int MAXIMUM_CAPACITY = 1 << 30;

定义哈希表的初始容量和最大容量，必须为2的幂

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;

定义桶中节点数到达8时，转化为树节点，小于6时转化为一般节点，及树桶的最小容量，最小容量应该至少为4倍的TREEIFY_THRESHOLD，这里定义为64。

 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;
        }
    }

节点的定义

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

哈希值的获取。若key为null，则返回0，若不为空，则将k的哈希值和高16位异或得到。

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;
    }

如果x是class C implements Comparable<>的实现形式，则return

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; // all other fields defaulted
    }

public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

HashMap的四种构造方法,包括初始化容量的构造函数，无参构造函数，参数为map的构造函数和指定初始化容量和loadFactor的构造函数。