Java源码分析——hashmap

hashmap起初是一个长度为16的数组，这个数组中每个值都是一个node对象，每次根据hash算法给这个值一个下标，当这个下标出现冲突时，当前Node中的元素next属性就等于这个重复的node对象，和当前Node组成一个单项链表，当链表长度为8时把链表转化为红黑树来处理。这是为了减少哈希碰撞，当链表长度为8时及时转换，能提高map的效率

1、在介绍hashmap之前首先简单来了解一下什么是二叉查找树和红黑树
1.1 二叉查找树
它具备两个特性：
1、左子树上所有结点的值小于等于它的根结点的值
2、右子树上所有结点的值大于等于它的根结点的值
如下图

二叉查找树的优势就是便于查找，比如说找到1这个值，查找次数最多等于这棵树的高度。然而它的缺陷在于多次插入新结点会导致这棵树的不平衡，比如下面这棵树

所以红黑树应运而生，红黑树在二叉树的基础上又增加了如下的规则：
1、节点是红色或黑色
2、根节点是黑色
3、每个叶子节点都是黑色的空节点（NIL节点）
4、每个红色节点的两个子节点都是黑色，而且每个叶子到根的所有路径上不能有连续的两个红色节点
5、从任一节点到其每个叶子的所有路径都包含着相同数量的黑色节点
下面就是一颗典型的红黑树

当插入或删除节点的时候，红黑树的规则有可能会被打破。这时候就需要做出一些调整来继续维持我们的规则，调整方法有两种：变色和旋转，而旋转又分为左旋转和右旋转，具体看参考文章，只要了解红黑树的自平衡思想就可以了。
好了接下来进入正题来看看我们的hashmap源码吧，源码中介绍hashmap的key和value都允许为空，但是他不能保证顺序随时间不变，hashmap中有三个重要的参数

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认初始化容量为16
static final float DEFAULT_LOAD_FACTOR = 0.75f; //默认负载因子 0.75
transient Node<K,V>[] table; // 声明一个node类型的数组，hashmap中实际操作的数组

Node为静态内部类
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;
      }
}

首先来看看put方法
public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
}
hash(key)方法将key进行hashcode运算返回一个hash值
static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); 
}

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; 
            //当第一次添加元素是满足table为null，此时触发resize()方法；此时resize()方法返回默认容量16
        if ((p = tab[i = (n - 1) & hash]) == null)
        //i=(n-1) & hash 计算出来的值i一定在1-n之间用，这个值去做下标计算出来的值如果为null，则新建一个node赋值给这个位置，那么如果i值重复，即发生数组下标的元素重复怎么办呢？代码在下面
            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 {
            //这里就是解决hash冲突的地方
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null); //新建一个node对象赋值给上一个对象的next引用，即以单向链表的方式存储Node。
                        if (binCount >= TREEIFY_THRESHOLD - 1) 
//当bincount大于等于7时链表转化为红黑树，jdk1.7是没有红黑树的，jdk1.8中加入红黑树是为了防止哈希表碰撞(任何哈希表的长度都是有限的，所以不同的数据项具有相同哈希值，此时不同数据项被定为到同一个桶，称为碰撞)，当链表长度为8时，转化为红黑树能提高map的效率
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key 当Key值重复时将新的value值替换
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

总结一下put方法
1、首先根据key的值算出hash值，然后根据hash值得出这个key在table数组中的位置上的对象p
2、如果这个对象为null，则直接赋值
3、如果不为null有三种情况，
3.1这个对象p的hash和key是否与所给的相等如果相等赋值为一个node对象e
3.2如果这个对象p是TreeNode红黑树类型，则循环树中的节点，判断p的key是否==或equals节点的key，成立则替换树里的value并返回旧值，不成立就添加到树中。
3.3否则就遍历单向链表，如果这个链表中的key==或equals对象p的key则替换，否则添加到链表中
4、判断是否需要替换vlaue值只需要判断hash值是否相等，Key值是否==或者equals