java常用类---HashMap 源码分析及用法

一、整体架构

HashMap从本质上来说，采用的是key--value的形式存取元素,底层实现为数组+链表+红黑树,初始容量是16,增长因子为0.75,非线程安全，允许null值;

常见属性：

//初始容量为 16
 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
 //最大容量
 static final int MAXIMUM_CAPACITY = 1 << 30;
 //负载因子默认值
 static final float DEFAULT_LOAD_FACTOR = 0.75f;
 //桶上的链表长度大于等于8时，链表转化成红黑树
 static final int TREEIFY_THRESHOLD = 8;
 //桶上的红黑树大小小于等于6时，红黑树转化成链表
 static final int UNTREEIFY_THRESHOLD = 6;
 //当数组容量大于 64 时，链表才会转化成红黑树
 static final int MIN_TREEIFY_CAPACITY = 64;
 //记录迭代过程中 HashMap 结构是否发生变化，如果有变化，迭代时会 fail-fast
 transient int modCount;
 //HashMap 的实际大小，可能不准(因为当你拿到这个值的时候，可能又发生了变化)
 transient int size;
 //存放数据的数组
 transient Node<K,V>[] table;
 // 扩容的门槛，有两种情况
 // 如果初始化时，给定数组大小的话，通过 tableSizeFor 方法计算，数组大小永远接近于 2 的幂次方，比如你给定初始化大小 19，实际上初始化大小为 32，为 2 的 5 次方。
 // 如果是通过 resize 方法进行扩容，大小 = 数组容量 * 0.75
 int threshold;
 //链表的节点
 static class Node<K,V> implements Map.Entry<K,V> {
 //红黑树的节点
 static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {}

二、源码分析

1 新增

新增key,value的大致步骤如下：

• 空数组有无初始化，如果没有进行初始化，先初始化
• 如果通过key的hash值能直接找到值，则直接跳到6，否则跳到3
• 如果hash冲突，两种解决方法：链表或者红黑树
• 如果是链表，递归循环，把新元素追加到队尾
• 如果是红黑树，调用红黑树的方法进行追加
• 通过2、4、5将新元素追加成功，再根据onlyIfAbsent判断是否需要覆盖
• 判断是否需要扩容，如果需要扩容则进行扩容

 具体源代码如下：

// 入参 hash：通过 hash 算法计算出来的值。
// 入参 onlyIfAbsent：false 表示即使 key 已经存在了，仍然会用新值覆盖原来的值，默认为 false
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    // n 表示数组的长度，i 为数组索引下标，p 为 i 下标位置的 Node 值
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //如果数组为空，使用 resize 方法初始化
    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);
    // 如果当前索引位置有值的处理方法，即我们常说的如何解决 hash 冲突
    else {
        // e 当前节点的临时变量
        Node<K,V> e; K k;
        // 如果 key 的 hash 和值都相等，直接把当前下标位置的 Node 值赋值给临时变量
        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) {
                // e = p.next 表示从头开始，遍历链表
                // p.next == null 表明 p 是链表的尾节点
                if ((e = p.next) == null) {
                    // 把新节点放到链表的尾部 
                    p.next = newNode(hash, key, value, null);
                    // 当链表的长度大于等于 8 时，链表转红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                // 链表遍历过程中，发现有元素和新增的元素相等，结束循环
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                //更改循环的当前元素，使 p 在遍历过程中，一直往后移动。
                p = e;
            }
        }
        // 说明新节点的新增位置已经找到了
        if (e != null) {
            V oldValue = e.value;
            // 当 onlyIfAbsent 为 false 时，才会覆盖值 
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            // 返回老值
            return oldValue;
        }
    }
    // 记录 HashMap 的数据结构发生了变化
    ++modCount;
    //如果 HashMap 的实际大小大于扩容的门槛，开始扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

源码思路如下图所示：

链表的新增

链表的新增比较简单，就是把新增的节点增加到链表的尾部，与LinkedList追加实现一样；当链表的长度大于等于8，此时链表就会转换为红黑树，转换的方法是treeifyBin，该方法有个判断，当链表长度大于等于8并且整个数组的长度大于64时，才会转换成红黑树，当数组长度小于64时，只会触发扩容；

红黑树新增

第一步：判断新增的节点在红黑树上是否已经存在

如果节点没有实现Comparable接口，则用equals进行判断，反之则用compareTo进行判断；

第二步：如果新增的节点已存在红黑树，则直接返回；反之新增的节点不存在红黑树中，则判断新增节点位于当前节点的左边还是右边，遵循左小右大的原则进行判断；

第三步：自选递归第一步和第二步，直到当前节点的左节点或者右节点为空，停止自旋，当前节点为我们新增节点的父节点；

第四步：把新增节点放置于当前节点左或右为空的节点，并于当前节点建立父子关系节点；

最后，进行着色和旋转，结束任务

源代码如下所示：

//入参 h：key 的hash值
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,int h, K k, V v) {
    Class<?> kc = null;
    boolean searched = false;
    //找到根节点
    TreeNode<K,V> root = (parent != null) ? root() : this;
    //自旋
    for (TreeNode<K,V> p = root;;) {
        int dir, ph; K pk;
        // p hash 值大于 h，说明 p 在 h 的右边
        if ((ph = p.hash) > h)
            dir = -1;
        // p hash 值小于 h，说明 p 在 h 的左边
        else if (ph < h)
            dir = 1;
        //要放进去key在当前树中已经存在了(equals来判断)
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p;
        //自己实现的Comparable的话，不能用hashcode比较了，需要用compareTo
        else if ((kc == null &&
                  //得到key的Class类型，如果key没有实现Comparable就是null
                  (kc = comparableClassFor(k)) == null) ||
                  //当前节点pk和入参k不等
                 (dir = compareComparables(kc, k, pk)) == 0) {
            if (!searched) {
                TreeNode<K,V> q, ch;
                searched = true;
                if (((ch = p.left) != null &&
                     (q = ch.find(h, k, kc)) != null) ||
                    ((ch = p.right) != null &&
                     (q = ch.find(h, k, kc)) != null))
                    return q;
            }
            dir = tieBreakOrder(k, pk);
        }

        TreeNode<K,V> xp = p;
        //找到和当前hashcode值相近的节点(当前节点的左右子节点其中一个为空即可)
        if ((p = (dir <= 0) ? p.left : p.right) == null) {
            Node<K,V> xpn = xp.next;
            //生成新的节点
            TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
            //把新节点放在当前子节点为空的位置上
            if (dir <= 0)
                xp.left = x;
            else
                xp.right = x;
            //当前节点和新节点建立父子，前后关系
            xp.next = x;
            x.parent = x.prev = xp;
            if (xpn != null)
                ((TreeNode<K,V>)xpn).prev = x;
            //balanceInsertion 对红黑树进行着色或旋转，以达到更多的查找效率，着色或旋转的几种场景如下
            //着色：新节点总是为红色；如果新节点的父亲是黑色，则不需要重新着色；如果父亲是红色，那么必须通过重新着色或者旋转的方法，再次达到红黑树的5个约束条件
            //旋转： 父亲是红色，叔叔是黑色时，进行旋转
            //如果当前节点是父亲的右节点，则进行左旋
            //如果当前节点是父亲的左节点，则进行右旋
          
            //moveRootToFront 方法是把算出来的root放到根节点上
            moveRootToFront(tab, balanceInsertion(root, x));
            return null;
        }
    }
}

 

最后，说一下我个人的感受，源码有些地方其实没看懂，大致理解是这样：

put操作：根据key的HashCode值计算hash值，根据Hash值得到数组元素的下标，如果数组的位置上没有其他元素直接将该元素放到该位置上，如果该位置上已有其他元素，则进行链表的形式存放，采用尾插法，新加入的放在链表的头部，最先加入的放在链表的尾部；

get操作：根据key的hashCode计算出hash值找到数组中对应的位置，然后根据key的equals方法找到链表中对应的位置

2 查找

HashMap查找主要分为三步：

第一步：根据hash算法定位数组索引的位置，equals判断当前节点是否为我们寻找的key,是的话返回，反之则继续

第二步：判断当前节点有无next节点，有的话判断是链表类型还是红黑树类型

第三步：针对链表类型和红黑树类型执行对应的查询方法；

三、常用方法总结

遍历HashMap

方式一：通过entrySet取得iter，然后逐个遍历

Iterator it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry pairs = (Map.Entry)it.next();
System.out.println(pairs.getKey() + " = " + pairs.getValue());

方式二：可以直接简单的for循环遍历

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
    System.out.println("Key = " + entry.getKey() + ", Value = " +entry.getValue());
}

存取值

public static void main(String[] args) {
         HashMap<String, Integer> map=new HashMap<>();
         map.put("1", 1);
         map.get("1");
}

空值判断

public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
        System.out.println(map.isEmpty());//true
        map.put("DEMO", 1);
        System.out.println(map.isEmpty());//false
}

是否包含key或者value

public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
        System.out.println(map.containsKey("DEMO"));//false
        map.put("DEMO", 1);
        System.out.println(map.containsKey("DEMO"));//true
}

public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
        System.out.println(map.containsValue(1));//false
        map.put("DEMO", 1);
        System.out.println(map.containsValue(1));//true
    }

删除key/value

public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
        System.out.println(map.remove("1"));//null
        map.put("DEMO", 2);
        System.out.println(map.remove("DEMO"));//2(删除的值)
}

public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
        map.put("DEMO1", 1);
        map.put("DEMO2", 2);
        System.out.println(map);//{DEMO1=1, DEMO2=2}
        System.out.println(map.remove("DEMO2", 1));//false
        System.out.println(map.remove("DEMO2", 2));//true
        System.out.println(map);//{DEMO1=1}
    }

显示所有的value值

public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
        System.out.println(map.values());//[]
        map.put("DEMO1", 1);
        map.put("DEMO2", 2);
        System.out.println(map.values());//[1, 2]
}

显示所有的key和value

public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
        System.out.println(map.entrySet());//[]
        map.put("DEMO1", 1);
        System.out.println(map.entrySet());//[DEMO1=1]
        map.put("DEMO2", 2);
        System.out.println(map.entrySet());//[DEMO1=1, DEMO2=2]
}