无序,不重复,可以有一个null 的key,value可以有多个(线程不安全)
1.将负载因子赋值默认 0.75f,不做任何操作 transient Node<K,V>[] table;
public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted }
2.一个参数的构造函数指定初始数组长度,调用两个参数的构造函数用指定的长度与默认的负载因子0.75
public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
3.将负载因子初始化,初始容量变量初始化(tableSizeFor经过此函数进行运算,使得指定长度变成其相近的2的n次冥){到此为止,构造函数都是准备,没有对数组的创建}{长度为什么会被调整为2的n次冥,主要是利用哈希计算位置的算法其长度为2的n次冥能减少哈希碰撞}
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); }
4.处理对指定的容量数,进行无符号位运算,在异或运算,1位+2位+4位+8位+16位=31,将int(32位)的高位都移动到低位啦。(在判断调教过的容量数是否合法)得到距离指定容量最近的2的n次冥的数作为指定容量
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 < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }
5.使用hash(key)计算key的哈希值,哈希值,key,value传递到putVal函数进行操作添加(false, true暂时不管你)
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
6.检查key,null就是哈希为0,通过hashCode得到哈希值,进行二次散列返还(二次散列,还是为了减少哈希碰撞)
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
7.核心代码(判断数组是否为空,空则扩容,不空则判断添加的元素对应位置是否有内容,没有直接添加,最后记录判断(容量是否扩容),有则判断是否形同,同则替换,不同则判断是否为树,为树则以树法添加,不是则以链法添加)
链法添加:死循环判断下一个元素是否为空,空直接添加
不为空,判断是否为相同key,同结束,到后面替换
不同继续循环{新元素挂最后,或者相同key替换value}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { //空的数组,用于使用暂存底层数组 Node<K,V>[] tab; //空结点用于暂存哈希冲突,或者就是保存头部节点,用于调整 Node<K,V> p; //两个变量,记录数组长度,与key计算出来的位置 int n, i; /* * 将底层数组(table){默认为null}赋值给原本定义的空数组(tab),在将长度保存与n * 判断底层数组是否为null或者长度为0,进行扩容resize(),得到新数组给原本定义的空数组(tab)将长度给n */ if ((tab = table) == null || (n = tab.length) == 0) //扩容方法下一小点展开 n = (tab = resize()).length; //i = (n - 1) & hash通过哈希计算位置记录在i,判断i位置是否为null(是否哈希冲突) if ((p = tab[i = (n - 1) & hash]) == null) //没有冲突直接赋值 tab[i] = newNode(hash, key, value, null); //=======================出现冲突解决冲突============================================= else { //创建空节点,记录冲突节点 Node<K,V> e; //创建key,记录冲突k 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 { //从头开始死循环next判断冲突 for (int binCount = 0; ; ++binCount) { //如果下一个节点没有东西直接链式挂上(没有啦就是循环到最后拉,尾插法) if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); //添加进去后判断会否大于等于7,0到7刚好是8,就是大于等于八个元素 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st //链式转树 treeifyBin(tab, hash); break; } //在链比较是否key相同{多方面比较},同直接结束在后面替换 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } //判断是否为空,默认为空,key相同则赋值相同节点,否则不赋值,所以,不为空则为key相同 if (e != null) { // existing mapping for 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; }
7.resize()扩容方法详解,初始化的指定量int oldThr = threshold,第一次用于初始化,之后用作阈值
判断老数组是否为空,不为空取出容量与阈值都左位运算相当于乘以2(如果容量乘2后还小于16 阈值到后面容量乘以 0.75f计算得到),容量确定直接到后面进行扩容
否则(数组为空)判断指定量是否为空(就是是否为0)不为空则直接用指定量作为初始容量扩容,指定量变成阈值量记录阈值,指定量新容量乘以0.75f
数组为空,指定量为空(0),直接使用默认16,与默认0.75f*16得到阈值(此刻指定量直接成为阈值使用)
新数组创建后,判断老数组是否有东西,有则拷贝无则结束return newTab;
final Node<K,V>[] resize() { //定义数组,保存原数组 Node<K,V>[] oldTab = table; //判断老数组是否为空,空则为0,不空则得到长度保存到oldCap中 int oldCap = (oldTab == null) ? 0 : oldTab.length; //记录指定长度(带参构造进行赋值过),没有指定的话默认为0 int oldThr = threshold; //定义新的长度,与指定长度初始为0 int newCap, newThr = 0; //oldCap原数组长度,有长度则进入 if (oldCap > 0) { //判断会否超过最大容量是则Integer.MAX_VALUE记录到指定长度中 if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } //没有达到最大长度,并且老容量大于16 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) //新的指定容量等于老的指定容量定的左移1位(2倍数) newThr = oldThr << 1; // double threshold } //原数组不大于零(原数组为空)判断指定容量是否有值,有则给新的容量 else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; //数组为空,没有指定容量,新容量定义为16,指定量定义为16*0.75f else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } //判断新的指定量(阈值)为0不,为这以新容量*0.75f求得指定量 if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } //指定量赋值给成员变量 threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) //创建新数组,为新容量 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; //判断老数组是否为空,空结束。不空循环拷贝到新数组 if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null; if (e.next == null) newTab[e.hash & (newCap - 1)] = e; else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); if (loTail != null) { loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
1