先看一段代码
public static void main(String[] args) {
Map<String,Object> map=new HashMap<>();
map.put("key=1","value=100");
Object put = map.put("key=1", "value=200");
System.out.println(put);
}
结果
//value=100
我们知道map中一个key只能对应一个value，我们再put这个key，会把原来的value返回回来。
为什么jdk1.7 HashMap 的实现原理：数组+链表
我们要向一个数组中存入一个值，我们必须知道你要存的下标
jdk是如何实现的呢
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
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++;
addEntry(hash, key, value, i);
return null;
}
可以看到它通过hash（）这个方法计算了一个hash值，再通过indexFor（）这个方法根据hash值和数组长度算出索引值i
采用链表的结构很大程度上解决了hash冲突问题。
为什么第二个在上面，这是由于jdk1.7 采用了头插的方式，这个下面再叙述
看一下这个indexFor方法
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的初始容量和扩容都是以2的次方来进行的，那么length-1换算成二进制的话肯定所有位都为1，就比如数组长度为8，2的3次方为8（1000），length-1的二进制表示就是111， 而按位与计算的原则是两位同时为“1”，结果才为“1”，否则为“0”。假设计算出来的hash值为135
135（10000111）&7（111）=7，现在，数组下标为7，所以h& (length-1)运算从数值上来讲其实等价于对length取模，也就是h%length。
如果不满足前提条件“HashMap的初始容量和扩容都是以2的次方来进行的”，会发生什么问题呢？
假设当前table的length是15，二进制表示为1111，那么length-1就是1110，此时有两个hash值为8和9的key需要计算索引值，计算过程如下：
//8的二进制表示：1000
//8&（length-1）= 1000 & 1110 = 1000，索引值即为8;
//9的二进制表示：1001
//9&（length-1）= 1001 & 1110 = 1000，索引值也为8;
这样一来就产生了相同的索引值，也就是说两个hash值为8和9的key会定位到数组中的同一个位置上形成链表，这就产生了碰撞
同时，我们也可以发现，当数组长度为15的时候，hash值会与length-1（1110）进行按位与，那么最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，会造成严重的空间浪费，更糟的是这种情况下，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率。
因此可以看出，只有当数组长度为2的n次方时，不同的key计算得出的index索引相同的几率才会较小，数据在数组上分布也比较均匀，碰撞的几率也小，相对的，查询的时候就不用遍历某个位置上的链表，这样查询效率也就较高了。
此外，位运算快于十进制运算，hashmap扩容也是按位扩容，这样同时也提高了运算效
HashMap的构造函数
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 //数组默认的容量为16
static final int MAXIMUM_CAPACITY = 1 << 30;//最大
static final float DEFAULT_LOAD_FACTOR = 0.75f;//扩容因子
static final Entry<?,?>[] EMPTY_TABLE = {};
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;//Entry数组
transient int size;
int threshold;//阈值
final float loadFactor;
transient int modCount;
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
/*
*initialCapacity传进来的数组容量，loadFactor扩容因子
*先对这两个值进行合法判断
*threshold = initialCapacity;把容量赋值给了一个阈值？
*/
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();
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public HashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
inflateTable(threshold);
putAllForCreate(m);
}
put方法
/*
* 首先判断table数组是否为空，如果是空的进行初始化 inflateTable（）
*/
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
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++;
addEntry(hash, key, value, i);
return null;
}
/*
* 这个方法主要是对table进行初始化，table = new Entry[capacity];
* 它为什么不直接把我们传进来的容量作为数组大小呢，
* 这个问题与上面容量和扩容都是2的次方数一样
* int capacity = roundUpToPowerOf2(toSize);找到大于这toSize的最小2的次方数
* 例如 7-----》8 9---------》16
* 那么它是如何实现的？
*/
private void inflateTable(int toSize) {
// Find a power of 2 >= toSize
int capacity = roundUpToPowerOf2(toSize);
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
/*
* 如果number》=MAXIMUM_CAPACITY 就等于MAXIMUM_CAPACITY 否则进入 (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1
* 如果 number > 1 进入 Integer.highestOneBit((number - 1) << 1) 否则等于1
* 这个方法的核心方法Integer.highestOneBit((number - 1) << 1)
* highestOneBit下面讲到是找到小于等于参数值的最小2的次方数
* 我们原本是想找到大于这toSize的最小2的次方数，这两个方法看似完全相反
* 我们想找》10的最小2的次方数
* 1010 左移一位
* 0001 1010
* highestOneBit（0001 1010）就是16
* 为什么要减一，如果传入了一个2的次方数，比如8，不减一会返回16，需要减一再左移
*/
private static int roundUpToPowerOf2(int number) {
// assert number >= 0 : "number must be non-negative";
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
/*
* 假设我想找到 小于等于10的最小2次方数
* 10------》1010
* 8-------》1000
*
* 现在看这个方法，假设我传进来了一个10( ... 0000 1010)
* 右移一位 ( ... 0000 0101) 进行或运算，有一则为一
* 结果 ( ... 0000 1111)
* 右移两位 ( ... 0000 0011) 进行或运算
* 结果 ( ... 0000 1111)
* 。。。
* 最终i= ( ... 0000 1111)
* i进行右移一位 （ ... 0000 0111)进行相减
* 最终的返回值为(... 0000 1000) 8
*/
public static int highestOneBit(int i) {
// HD, Figure 3-1
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
return i - (i >>> 1);
}
2014
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
