基本介绍

其实HashMap底层是个什么东西我们之前也讲过, 就是一个哈希桶(差不多可以看成一个数组), 然后每一个节点又连接着链表/红黑树之类的, 下面让我们看一看具体在源码上是怎样实现的:

常量及其它

-> static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

//这个指代的是哈希桶的大小, 默认为16

-> static final float DEFAULT_LOAD_FACTOR = 0.75f;

//默认的负载因子 -> 0.75

-> static final int TREEIFY_THRESHOLD = 8;

//树化的条件之一, 就是指当一个节点上的链表长度大于8时(也不一定是8, 但跟8是有关的, 后面讲put的时候再说),就会从链表转换为红黑树

-> static final int MIN_TREEIFY_CAPACITY =  64;

//树化的条件之一, 就是指当哈希桶的大小如果大于64(数组的长度), 就会将链表转换成红黑树

-> static final int UNTREEIFY_THRESHOLD = 6;

//解树化的条件, 当红黑树的大小小于8时, 就会从红黑树转换回链表. 

-> static class Node<K, V> implements Map.Entry<K, V> {...

这段代码定义了一个静态内部类'Node', 该类实现了'Map.Entry<K, V>'接口, 表示哈希表中的一个节点, 用于存储键值对.

 构造方法

含指定容量, 负载因子的

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

这个是提供了指定容量, 负载因子的, 玩家可以自行设置这两个参数. 需要注意的是在:

if(initialCapacity > MAXIMUM_CAPACITY) {}

这个中, MAXIMUM_CAPACITY是指1>>30, 也就是说当玩家设置的值大于这个值之后, 就会被设置为这个值(显而易见, 为了防止移除) 

含指定容量的

    public HashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR);}

这个很好理解, 就是当不给负载因子时, 就是默认的0.75, 然后通过this()调用上面的构造方法. 

俺一无所有

    public HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted}

这个就比较令人匪夷所思了, 它只有默认的负载因子(当然,还是0.75). 然后奇怪的是它居然没有给设置容量! 没事, 让子弹飞一会.

put方法

    public V put(K key, V value) {return putVal(hash(key), key, value, false, true);}

让我们先来看一下里面的hash()方法.

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

这里采用了将key的hashCode()值与h右移 16位取异或得到哈希值.

这种位操作目的是将hashCode()返回的高位和低位进行混合, 增加哈希值的随机性和分布性, 从而减少哈希冲突的概率.

再来看一下putVal()方法.

     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;if ((p = tab[i = (n - 1) & hash]) == null)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 {for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1sttreeifyBin(tab, hash);break;}if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}if (e != null) { // existing mapping for keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;if (++size > threshold)resize();afterNodeInsertion(evict);return null;}

不难发现在4, 5行中, 

if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;

我们发现当这个传来的哈希标为空/或者大小为0时, 会让表调用resize().

这里是resize()中的部分内容:

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

table = newTab;

 通过这个, 我们就可以得出结论, 在第一次put的时候, 哈希桶大小分配为了默认的newCap(其实是16).

继续分析putVal()方法中的剩余部分.

if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);

 在这里,  就是哈希表中插入新键值对的逻辑(就是哈希桶这个位置为空), 通过(n - 1) & hash的方式映射到数组索引i上, 这是因为 'n'应该是2的幂次方(即哈希表长度应该是2的幂次方), 才能保证哈希值均匀分布. 然后调用newNode完成了插入操作. 

p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1sttreeifyBin(tab, hash);
break;

当需要插到链表/红黑树上时, 就需要通过尾插法插入, 在这里, 我们发现, 当链表长度大于 8 - 1时, 就会通过treeifyBin方法进行树化.  

那么到这里就讲完了(我讲的是比较爱考的), 其它部分如果感兴趣的话希望你们自己看看源码推理推理.

下了...