1 概述

2 HashMap的数据结构

在Java中,最基本的结构就是两种,一个是数组,另外一个是模拟指针(引用),所有的数据结构都可以用这两个基本结构来构造,HashMap也不例外. HashMap实际上是一个"链表散列"的数据结构,即数组和链表的结合体.

HashMap的主结构类似于一个数组,添加值时通过key确定储存位置.
每个位置是一个Entry的数据结构,该结构可组成链表.
当发生冲突时,相同hash值的键值对会组成链表.
这种数组+链表的组合形式大部分情况下都能有不错的性能效果,Java6、7就是这样设计的. 然而,在极端情况下,一组（比如经过精心设计的）键值对都发生了冲突，这时的哈希结构就会退化成一个链表，使HashMap性能急剧下降.所以在Java8中,HashMap的结构实现变为数组+链表+红黑树

可以看出,HashMap底层就是一个数组结构
数组中的每一项又是一个链表
当新建一个HashMap时,就会初始化一个数组.

3 三大集合与迭代子

public class HashMapExam {
    public static void main(String[] args) {
        Map map = new HashMap(16);
        for (int i = 0; i < 15; i++) {
            map.put(i, new String(new char[]{(char) ('A'+ i)}));
        }
        System.out.println("======keySet=======");
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("======values=======");
        Collection values = map.values();
        Iterator stringIterator=values.iterator();
        while (stringIterator.hasNext()) {
            System.out.println(stringIterator.next());
        }
        System.out.println("======entrySet=======");
        for (Map.Entry entry : map.entrySet()) {
            System.out.println(entry);
        }
    }
}

4 源码分析

//默认的初始容量16,且实际容量是2的整数幂     static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    //最大容量(传入容量过大将被这个值替换)     static final int MAXIMUM_CAPACITY = 1 << 30;
    // 默认加载因子为0.75(当表达到3/4满时,才会再散列),这个因子在时间和空间代价之间达到了平衡.更高的因子可以降低表所需的空间,但是会增加查找代价,而查找是最频繁操作     static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //桶的树化阈值：即 链表转成红黑树的阈值，在存储数据时，当链表长度 >= 8时，则将链表转换成红黑树     static final int TREEIFY_THRESHOLD = 8;
   // 桶的链表还原阈值：即 红黑树转为链表的阈值，当在扩容（resize（））时（HashMap的数据存储位置会重新计算），在重新计算存储位置后，当原有的红黑树内数量 <= 6时，则将 红黑树转换成链表     static final int UNTREEIFY_THRESHOLD = 6;
   //最小树形化容量阈值：即 当哈希表中的容量 > 该值时，才允许树形化链表 （即 将链表 转换成红黑树）

// 为了避免扩容/树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD     // 小于该值时使用的是扩容哦!!!     static final int MIN_TREEIFY_CAPACITY = 64;
    // 存储数据的Node数组,长度是2的幂.     // HashMap采用链表法解决冲突，每一个Node本质上是一个单向链表     //HashMap底层存储的数据结构,是一个Node数组.上面得知Node类为元素维护了一个单向链表.至此,HashMap存储的数据结构也就很清晰了:维护了一个数组,每个数组又维护了一个单向链表.之所以这么设计,考虑到遇到哈希冲突的时候,同index的value值就用单向链表来维护     //与 JDK 1.7 的对比（Entry类），仅仅只是换了名字     transient Node[] table;
    // HashMap的底层数组中已用槽的数量     transient int size;
    // HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）     int threshold;
    // 负载因子实际大小     final float loadFactor;
    // HashMap被改变的次数     transient int modCount;
    // 指定“容量大小”和“加载因子”的构造函数,是最基础的构造函数     public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        // HashMap的最大容量只能是MAXIMUM_CAPACITY         if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //负载因子须大于0         if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        // 设置"负载因子"         this.loadFactor = loadFactor;
        // 设置"HashMap阈值",当HashMap中存储数据的数量达到threshold时,就需将HashMap的容量加倍         this.threshold = tableSizeFor(initialCapacity);
    }

static final int tableSizeFor(int cap) {
  int n = cap - 1;
  n |= n >>> 1;
  n |= n >>> 2;
  n |= n >>> 4;
  n |= n >>> 8;
  n |= n >>> 16;
  return (n = MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
  }

• int n = cap - 1
  给定的cap 减 1,为了避免参数cap本来就是2的幂次方,这样一来,经过后续操作，cap将会变成2 * cap,是不符合我们预期的
• n |= n >>> 1
  n >>> 1 : n无符号右移1位,即n二进制最高位的1右移一位
  n | (n >>> 1) 导致 n二进制的高2位值为1
  目前n的高1~2位均为1
• n |= n >>> 2
  n继续无符号右移2位
  n | (n >>> 2) 导致n二进制表示的高34位经过运算值均为1
  目前n的高14位均为1
• n |= n >>> 4
  n继续无符号右移4位
  n | (n >>> 4) 导致n二进制表示的高58位经过运算值均为1
  目前n的高18位均为1
• n |= n >>> 8
  n继续无符号右移8位
  n | (n >>> 8) 导致n二进制表示的高916位经过运算值均为1
  目前n的高116位均为1

本内容属于网络转载，文中涉及图片等内容如有侵权，请联系编辑删除