0001

hashMap 源码 简单解析。


public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
{

/**
* The default initial capacity - MUST be a power of two.
*2的次方 必须是 默认初始化的大小 是16
*/
static final int DEFAULT_INITIAL_CAPACITY = 16;

/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*左移位 最大值 1<<30 = 1 073 741 824 2 的30次方
*2<<3 2*2的3次方
*/
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
* The load factor used when none specified in constructor.
*默认负载因子 （当没有指定负载因子时 采用默认的）
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
* The table, resized as necessary. Length MUST Always be a power of two.
*数组的长度必须为2 的次幂
*/
transient Entry[] table;

/**
* The number of key-value mappings contained in this map.
*/
transient int size;

/**
* The next size value at which to resize (capacity * load factor).
* 数组扩容时的长度是根据负载因子和默认长度计算出来的 eg：默认loadFactor = 0.75 ，catacity = 16 则当数组容量超过12时就进行扩容
*容量为capacity 的2倍 即2的次幂。
* @serial
*/
int threshold;

/**
* The load factor for the hash table.
*为数组准备的负载因子 可以自定义大小
* @serial
*/
final float loadFactor;

/**
* The number of times this HashMap has been structurally modified
* Structural modifications are those that change the number of mappings in
* the HashMap or otherwise modify its internal structure (e.g.,
* rehash). This field is used to make iterators on Collection-views of
* the HashMap fail-fast. (See ConcurrentModificationException).
*记录hashMap 被修改的次数，每次都是加一操作。
*/
transient volatile int modCount;


//静态类 用来存放参数
static class Entry<K,V> implements Map.Entry<K,V> {
final K key; ----key存放键值
V value; ----存放键
Entry<K,V> next; 指向下一个对象，用来当位置重复时做链表用
final int hash; ----存放hash 值， 这里不是hashcode 是 通过hashmap的hash算法得到的hash值 但是是和hashcode有关
如果hashcode相等，则此值也是相同的

/**


/**
* Offloaded version of put for null keys
*/
private V putForNullKey(V value) {
/×××
key==null时调用



××/
for (Entry<K,V> e = table[0]; e != null; e = e.next) {//在0索引位置开始向后循环查找查找 注意next 链表结构
//如果这个地方有null 的key 则替换掉，否则调用下面的方法
//注意：null的key 都是存储在0索引位置的，即table数组的第一位如果有链表则向下连
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);//这个方法是存储null 的key的

return null;
}


/**
* Adds a new entry with the specified key, value and hash code to
* the specified bucket. It is the responsibility of this
* method to resize the table if appropriate.
*
* Subclass overrides this to alter the behavior of put method.
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
//buckectIndex 是要存放value值在数组中的位置。
//首先把backetIndex位置的数取出来，指向e
Entry<K,V> e = table[bucketIndex];

将backetIndex 位置存入新的entry 对象，此对象把原先的entry对象放到了next里
根据最近使用的数据在不远的将来还会在使用的原则，把新的entry对象放到了此处索引位置的最上面，以前的老的entry对象向下链接。
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
判断数组的长度如果超出了threshold= capacity*loadFactory 16*0.75 如果超过或者相等就会扩容数组为原来的2倍
if (size++ >= threshold)
resize(2 * table.length);
}

/**
* Associates the specified value with the specified key in this map.
* If the map previously contained a mapping for the key, the old
* value is replaced.
*如果map里有key（通过e.hash == hash && ((k = e.key) == key || key.equals(k)) 判断的） 则用新值替换老的值，并把oldvalue返回
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
* @return the previous value associated with <tt>key</tt>, or
* <tt>null</tt> if there was no mapping for <tt>key</tt>.
* (A <tt>null</tt> return can also indicate that the map
* previously associated <tt>null</tt> with <tt>key</tt>.)
*上面的一段大体意思是 key 关联指定的value 。或者value去关联指定的key
*/
public V put(K key, V value) {
if (key == null)
/××

先说说key==null吧
如果key==null 调用putFor NUllKey 方法 参数为value



×××/
return putForNullKey(value);


int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);

//判断此位置的链表上是否有这个key，如果有 则替换没有就调用add方法添加
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}

modCount++;
//此处和上面是一样的，记住entry对象里存了hash值，key，value，和数组的索引位置
addEntry(hash, key, value, i);
return null;
}