HashMap(jdk8)
特点
- 数组+链表+红黑树
- key非重复
- 双列元素
- key和value可以为空
- key只能有一个null
- 非安全
构造器
无参构造器
使用无参构造，第一次put时，会先去校验table表中的长度是否>0，如果小于0，则回去查看初始容量threshold是否大于0，如果没有指定threshold初始容量，则会使用默认的初始容量 16作为table表的长度，默认的加载因子为0.75，只有当集合put时，才会真正的将table表的长度进行扩容，且下次扩容是达到 初始容量*加载因子=临界值时 会再次触发扩容。
/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}指定初始化容量和加载因子的构造器
- 使用初始化容量和加载因子的构造器初始容量不得小于0
- 如果初始化容量的大小大于
1 << 30(1的30次方)，会直接使用1的30次方作为初始容量的大小。 - 加载因子不可小于等于0或者不是一个float类型。
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);
}使用单参初始容量构造器
- 初始容量不可大于1的30次方，且不可小于0
- 默认的加载因子为0.75
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}使用传入map集合的构造器
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 计算出容量与加载因子
// 如果容量超过加载因子，则进行扩容。
// 随后遍历Map依次进行put操作
putMapEntries(m, false);
}扩容机制
- hashMap默认初始化是16个长度，其中默认的加载因子是0.75，当集合中添加的元素长度达到一个
临界值--集合内元素总数 * 0.75=临界值，即12，当添加完一个元素此时集合内的长度>12时会进行一个扩容，扩容按照当前容量的两倍进行扩容，并且根据当前的加载因子计算出临界值,当下一次再次触发，则会进行相同的操作。 - 当我们在table（即hashmap中的数组）表中，存储元素时，会先去根据key，获取对应的hash值（非hashcode值），是根据按位算法--(h = key.hashCode()) ^ (h >>> 16)--，拿到这个值后，会和表中的
长度-1进行按位运算，得到一个索引值，如果表中对应的索引值的元素为为空，则直接将元素添加至数组中的索引，如果存在，则会比较新元素key的hash值与已经存在的元素key的hash值是否相等，并且两个元素的key是否相等，如果相等说明元素重复，则会进行替换操作，如果不相等，则会先去判断，这个索引处的对象类型是不是一颗红黑树，如果是红黑树，则会按照红黑树的方式存储，如果是一条链表，则会依次比较链中元素是否相等，如果相等，直接退出，如果不相等，则会在链的最后面增加一个元素，如果创建完后该链的长度>=8，则会判断表table长度是否是64，如果不是64，则会优先扩容table，再往链尾添加新元素的Node节点，如果是64，则会将该链形成红黑树结构。
EntitySet
关于HashMap集合的内部类EntitySet解析
- 已知，Map集合是键值对存储，且经源码分析，其实，每个k-v元素本质就是一个Node节点对象（HashMap内部类Node<K,V>）,且这个Node对象实现了Map接口的Entity接口，其实当我们初始化一个Node节点时，
newNode(hash, key, value, null)，实际上Map接口的内部类Entity<K,V>保存了Node对象的引用，因为多态的关系，Node对象即是Node类型，又可以向上转型Entity<K,V>,即Entity<K,V>又可以向下转型。 为了方便对HashMap集合的遍历，即会把保存在HashMap中的Node节点的引用保存在EntitySet一份，该集合存放的元素类型是Entity，而一个Entity对象就有K-V,EntitySet<Entity<K,V>>，即：Set<Map.Entity<K,V>>,EntitySet中，定义的类型是Map.Entity,但是实际上存放的还是 HashMap$Node，这是因为Node<K,V> implements Map.Entity<K,V>,当把HashMap$Node 对象存放到entitySet中后 方便了我们的遍历和取值。
HashMap扩容源码
/** * 初始化或加倍表大小。如果为空，则分配 * 符合初始容量目标保持在现场阈值。 * 否则，因为我们使用的是二次幂扩展，所以 * 来自每个 bin 的元素必须保持相同的索引，或者移动 * 在新表中具有 2 次方偏移。 * * @return 表格 */ final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; if (oldCap > 0) { if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } 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.HashMap的key不可以重复，如果再次put一个已有的key，会将集合中的key对应的value替换成新put的value
2.HashMap不安全，因为类中没有同步机制。
3.HashMap效率高，因为HashMap的底层是数组+单向链表+红黑树。
4.HashMap的key和value都可以为空，但是key只能有一个空。
5.HashMap的扩容的触发可以是集合内元素的大于临界值，会进行2倍的扩容，单条链表的长度>=8时且table不是64时会进行2倍的扩容
6.HashMap进行put时会根据key计算出来的hash值与当前table表的长度-1进行按位与计算出table中的索引
7.如果hash值计算的索引处在table表中已存在，则会进行对比，如果key的hash值不一样或者key的equals不满足则会进行红黑树结构的转换或单向链表的追加。
8.HashMap是无序的，因为底层是hash表的方式进行存储的，因此存储的顺序和取出来的顺序是不同的。
9.HashMap使用无参或者指定容量和指定容量、加载因子的构造器，只会在HashMap类中记录threshold初始容量长度和loadFactor加载因子，只有等到put时，才会真正的将集合的容量进行扩容。
HashTable
特点
- 安全
- 效率低
- key和value都不允许为空
- 当key存在时，会进行value替换
- 数组+链表
解析
- Hashtable默认初始容量是11个长度，且Hashtable初始化容量是在put前完成的。
- Hashtable默认的加载因子是0.75，且临界值为 threshold=(int)Math.min(initialCapacity loadFactor, MAX_ARRAY_SIZE + 1),也就是说加载因子最大为MAX_ARRAY_SIZE + 1,但是默认的还是initialCapacity loadFactor，初始容量*加载因子。
- 如果进行put操作，添加元素之前会先去判断 count >= threshold（当前集合的大小是否大于或等于
临界值）,如果大于临界值，则会按照int newCapacity = (oldCapacity << 1) + 1 （oldCapacity = table.length;），进行扩容，也就是说每次扩容都为`当前的容量 2 +1,临界值依然按照threshold = (int)Math.min(newCapacity loadFactor, MAX_ARRAY_SIZE + 1)的方式进行扩容; - Hashtable每次扩容完毕，都会进行
重新hash的操作，在扩容前会先将当前集合所有的Node数组拿到，再将table表指向一个新的空的数组，数组大小为扩容后的容量，扩容后，将所有的Node数组中的对象Node进行key的重新hash。 进行put操作时如果当前容量 >=临界值 则会按照当前容量2倍+1的方式进行扩容，扩容前会将当前table表备份一份，扩容完毕后，会进行一个
重新hash的操作，执行完毕后会重新hash新元素的key的索引值，随后再将元素放入到新的table表中。Hashtable构造器
Hashtable所有构造都基于下面这个构造器进行初始化。
public Hashtable(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal Load: "+loadFactor); if (initialCapacity==0) initialCapacity = 1; this.loadFactor = loadFactor; table = new Entry<?,?>[initialCapacity]; threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1); }put方法源码
public synchronized V put(K key, V value) { // Make sure the value is not null if (value == null) { throw new NullPointerException(); } // Makes sure the key is not already in the hashtable. Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; @SuppressWarnings("unchecked") Entry<K,V> entry = (Entry<K,V>)tab[index]; for(; entry != null ; entry = entry.next) { if ((entry.hash == hash) && entry.key.equals(key)) { V old = entry.value; entry.value = value; return old; } } addEntry(hash, key, value, index); return null; }addEntry方法
private void addEntry(int hash, K key, V value, int index) { modCount++; Entry<?,?> tab[] = table; if (count >= threshold) { // Rehash the table if the threshold is exceeded rehash(); tab = table; hash = key.hashCode(); index = (hash & 0x7FFFFFFF) % tab.length; } // Creates the new entry. @SuppressWarnings("unchecked") Entry<K,V> e = (Entry<K,V>) tab[index]; tab[index] = new Entry<>(hash, key, value, e); count++; }重新hash方法
protected void rehash() { int oldCapacity = table.length; Entry<?,?>[] oldMap = table; // overflow-conscious code int newCapacity = (oldCapacity << 1) + 1; if (newCapacity - MAX_ARRAY_SIZE > 0) { if (oldCapacity == MAX_ARRAY_SIZE) // Keep running with MAX_ARRAY_SIZE buckets return; newCapacity = MAX_ARRAY_SIZE; } Entry<?,?>[] newMap = new Entry<?,?>[newCapacity]; modCount++; threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1); table = newMap; for (int i = oldCapacity ; i-- > 0 ;) { for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) { Entry<K,V> e = old; old = old.next; int index = (e.hash & 0x7FFFFFFF) % newCapacity; e.next = (Entry<K,V>)newMap[index]; newMap[index] = e; } } }
java
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。