一，HashMap的成员变量
1，
//默认的初始容量，2的4次方=16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
2，
//最大容量，2的30次方 1个G
static final int MAXIMUM_CAPACITY = 1 << 30;
3，//Entry数组，每一个元素都是键值对应的对象
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
4，//hashmap的实际容量
transient int size;
5，//负载因子
final float loadFactor;
6， //记录改变map结构的操作次数
transient int modCount;
7， //默认的扩容阈值
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
8，//空的entry数组
static final Entry<?,?>[] EMPTY_TABLE = {};
二，HashMap的构造函数。
它总共有三个构造函数。
1，第一个构造函数，提供初始化的map容量和初始化的负载因子。
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;
threshold = initialCapacity;
init();
}
2，第二个构造函数，根据提供的初始化容量进行新建hashmap，负载因子采用默认的0.75
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
3，第三个构造函数，没有输入参数，默认初始大小为16，负载因子为0.75
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
三，hash值的计算和根据哈希值索引存储位置。
1，hash值计算，通过调用k本身的hashcode方法获取哈希值，也就是说作为HashMap的key必须要要重写了hashCode()这个方法，像是一些常用的类型比如String，Integer这些都已经重写好了hashCode这个方法。比如：String的hashCode方法。
//String类型自带的hashCode方法public int hashCode() {int h = hash;if (h == 0 && value.length > 0) {char val[] = value;for (int i = 0; i < value.length; i++) {h = 31 * h + val[i];}hash = h;}return h;}
hash值计算
final int hash(Object k) {int h = hashSeed;if (0 != h && k instanceof String) {return sun.misc.Hashing.stringHash32((String) k);}h ^= k.hashCode();// This function ensures that hashCodes that differ only by// constant multiples at each bit position have a bounded// number of collisions (approximately 8 at default load factor).h ^= (h >>> 20) ^ (h >>> 12);return h ^ (h >>> 7) ^ (h >>> 4);}
2，存储索引，h和length-1相与，其实就是h对length取模，相与效率高很多。
另外注意一下，源码中有注释说length一定要2的非零次方，也就是说长度一定要为偶数，这是因为length为偶数的话，length-1就为奇数，这样它的最低位为1，相与的时候结果就可以为0也可以为1，但如果length为奇数的话，相与后的结果就只能为0，也就是说只有下标为偶数的才能被用来存元素，这样的话就浪费了很大的空间。
/*** Returns index for hash code h.*/static int indexFor(int h, int length) {// assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";return h & (length-1);}
四，HashMap存储数据
下面是put方法源码，
public V put(K key, V value) {//如果这时候HashMap为空，就建一个表if (table == EMPTY_TABLE) {inflateTable(threshold);}//HashMap中key是可以为Null的，但是key不允许重复，所以它要遍历以前存的key有没有null的，如果有就覆盖掉原来的valueif (key == null)return putForNullKey(value);//计算key的hash值int hash = hash(key);//根据hash值索引存储位置int i = indexFor(hash, table.length);//循环遍历table[i]这个位置的entry链表，如果已经存在相同的key就用新的value覆盖旧的valuefor (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;}}//修改次数加1modCount++;//加入到entry数组addEntry(hash, key, value, i);//如果是第一次添加这key就返回null，否则返回原来key对应的oldvalue;return null;}
五，HashMap的扩容
上面的put方法中最终调用的是addEntry这个方法进行插入的，看下面源码的第三行，如果大于给定的阈值，就会进行扩容
void addEntry(int hash, K key, V value, int bucketIndex) {if ((size >= threshold) && (null != table[bucketIndex])) {resize(2 * table.length);hash = (null != key) ? hash(key) : 0;bucketIndex = indexFor(hash, table.length);}createEntry(hash, key, value, bucketIndex);}
我们具体看看是怎么扩容的
void resize(int newCapacity) {Entry[] oldTable = table;int oldCapacity = oldTable.length;if (oldCapacity == MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return;}Entry[] newTable = new Entry[newCapacity];transfer(newTable, initHashSeedAsNeeded(newCapacity));table = newTable;threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);}
上面代码第四行，如果原来的容量已经是最大容量了，就不进行扩容，否则，新建一个新的表，大小是原来的两倍，然后对原来阈值重新计算。
六，Entry内部类
其实由前面我们已经知道，HashMap存储是以Entry这个内部类进行存储的，建立一个这种类型的数组
static class Entry<K,V> implements Map.Entry<K,V> {final K key;V value;Entry<K,V> next;int hash;/*** Creates new entry.*/Entry(int h, K k, V v, Entry<K,V> n) {value = v;next = n;key = k;hash = h;}public final K getKey() {return key;}public final V getValue() {return value;}public final V setValue(V newValue) {V oldValue = value;value = newValue;return oldValue;}public final boolean equals(Object o) {//如果不是Entry实例就返回falseif (!(o instanceof Map.Entry))return false;Map.Entry e = (Map.Entry)o;Object k1 = getKey();Object k2 = e.getKey();//key和value都相等才返回trueif (k1 == k2 || (k1 != null && k1.equals(k2))) {Object v1 = getValue();Object v2 = e.getValue();if (v1 == v2 || (v1 != null && v1.equals(v2)))return true;}return false;}public final int hashCode() {return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());}public final String toString() {return getKey() + "=" + getValue();}}
上面这个类还是很简单的，一对key和value，构造函数就是对key和value进行赋值，然后对外主要提供getKey(),getValue(),setValue()三个方法用于获取键值，value值，设置value值。然后还重写了equals方法。
先分析到这边，有时间继续。
1378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
