0、基于jdk1.8源码所分析
1、一些常量
/**
* The default initial capacity - MUST be a power of two. 默认的初始容量是2的幂。 默认为2的4次方 16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* The maximum capacity, used if a higher value is implicitly specified 最大容量。 2的30次方
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* The load factor used when none specified in constructor. 负载因子
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
2、什么是初始化容量以及负载因子
初始化容量默认16.就是map里面能存16个键值队。
负载因子0.75 即: 一旦存放元素个数 >= 0.75*16 -1 = 11 就会进行扩容
3、那么负载因子为什么要是0.75 源码注释这么写
Ideally, under random hashCodes, the frequency of
* nodes in bins follows a Poisson distribution
* (http://en.wikipedia.org/wiki/Poisson_distribution) with a
* parameter of about 0.5 on average for the default resizing
* threshold of 0.75, although with a large variance because of
* resizing granularity. Ignoring variance, the expected
* occurrences of list size k are (exp(-0.5) * pow(0.5, k) /
* factorial(k)). The first values are:
*
* 0: 0.60653066
* 1: 0.30326533
* 2: 0.07581633
* 3: 0.01263606
* 4: 0.00157952
* 5: 0.00015795
* 6: 0.00001316
* 7: 0.00000094
* 8: 0.00000006
*
在理想情况下,使用随机哈希码,节点出现的频率在hash桶中遵循泊松分布,同时给出了桶中元素个数和概率的对照表。
从上面的表中可以看到当桶中元素到达8个的时候,概率已经变得非常小,也就是说用0.75作为加载因子,每个碰撞位置的链表长度超过8个是几乎不可能的。
所以用0.75.
1、构造方法
// 默认构造函数。
HashMap()
// 指定“容量大小”的构造函数
HashMap(int capacity)
// 指定“容量大小”和“加载因子”的构造函数
HashMap(int capacity, float loadFactor)
// 包含“子Map”的构造函数
HashMap(Map<? extends K, ? extends V> map)
2、方法
void clear() 清空容器中元素
Object clone() 克隆
boolean containsKey(Object key) 判断是否包含key
boolean containsValue(Object value) 是否包含value
Set<Entry<K, V>> entrySet() 所有的key的集合
V get(Object key)
boolean isEmpty()
Set<K> keySet()
V put(K key, V value)
void putAll(Map<? extends K, ? extends V> map)
V remove(Object key)
int size() map容器中元素个数
Collection<V> values()
3、存储的方式
1、hashmap底层是以数组方式进行存储。将key-value对作为数组中的一个元素进行存储。
2、key-value都是Map.Entry中的属性。其中将key的值进行hash之后进行存储,即每一个key都是计算hash值,然后再存储。一个Hash值对应一个数组下标,数组下标是根据hash值和数组长度计算得来。
3、由于不同的key有可能hash值相同,即该位置的数组中的元素出现两个,对于这种情况,hashmap采用链表形式进行存储。
//存储kev -value键值队
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //hash值
final K key; //key
V value; // value值
Node<K,V> next; // 链表引用. 防止出现key不同,hash相同
//构造函数,生成节点
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
// 重写hashcode方法
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
//同一个key时,新值替换旧值,返回旧的值
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
//重写equals方法
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
4、put方法
public V put(K key, V value) {
//hash(key) 生成hashCode
return putVal(hash(key), key, value, false, true);
}
//用来生成hashCode
tatic final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
* Implements Map.put and related methods
* @param hash hash for key hash值
* @param key the key key
* @param value the value to put value
* @param onlyIfAbsent if true, don't change existing value 如果为true则不能更改
* @param evict if false, the table is in creation mode. 如果为false则表为创建模式
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab为数组的大小,p表示tab上的某个节点,n为tab的长度,i为tab的下表
Node<K,V>[] tab; Node<K,V> p; int n, i;
//首次存储,初始化空间(tab==null)
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//(n-1)&hash得到下标i。有时间我会讲解如何算出来的。将tab[i]赋值给p.若当前p==null,则当前下标没有节点,直接赋值
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {//说明当前数组的该下标有值,开始链表的方式。
Node<K,V> e; K k; //定义e表示即将插入的节点。 定义K
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) //判断原来的链表中有没有key值相等的,相等就从新赋值就结束了
e = p;
else if (p instanceof TreeNode)//说明hash相等,但是key不相等。就往红黑树放。判断有没有生成红黑树节点个大于8?
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 1st
treeifyBin(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 key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
待更新