HashMap知识总结
1、hashMap继承及实现接口。
Map<K,V>,Cloneable , Serializable,Map.Entry,Iterator
2、特点分析（根据其继承类及实现的接口）
（1）Map
- collection（存储单值）和Map（存储 双值）是集合框架库的两个顶级接口。
- 以key->value的形式存储数据，key是不重复的，元素位置由key决定。可以通过key去寻找key-value的位置，从而得到value的值，适合做查找工作。
（2）Cloneable
- 可以使用clone方法
（3）Serializable
- 可以被序列化
（4）Map.Entry
- 可以存储key-value具体数值。
（5）Iterator
- 迭代器，只能从前往后进行遍历。
3、插入顺序：hashmap中元素的顺序，不是插入顺序。因为key-value的存储位置是由key决定的。
4、使用场景：由于hashmap查询效率较高，并且可以通过key去查询对应的value。
5、源码分析
（1）底层数据结构
- 数组+链表（V1.7）
- 数组+链表或者数组+红黑树（V1.8）
（2）构造函数： 数组默认初始容量为0，当添加第一个元素时，容量变为16。
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final Entry<?,?>[] EMPTY_TABLE = {};
MyHashMap(){
table = EMPTY_TABLE;
threshold = 0.75;
}
（3）hash算法：通过key值,调用hashcode()函数计算key的hashcode。
注意的点：
- 一进入函数需要对key是否为空进行判断，若为空，置其hashcode为0。
- 对通过hashcode()计算出的hash值进行扰动处理，目的是保证其为正数和减低hashcode的重复率，降低hash冲突。
public int hash(K key){
if(key==null){
return 0;
}
//key.hashCode()是一个负数
int h = key.hashCode();
//扰动处理:hashcode会重复的，目的是降低hashcode重复率
h ^=(h>>>20) ^ (h>>>12);// >>>无符号的右移
h = h^(h>>>7)^(h>>>4);
return h;
//h % table.length 原来的，因为位运算符的运算效率高于算数运算符
//前提条件是table.length是2的幂
}
（4）indexOf()方法：计算下标。
参数：h（对key进行计算后的hashcode）
按位与操作：提高计算效率。
public int indexOf(int h){
return h & (table.length - 1);
}
（5）resize()扩容方法：对hashMap进行扩容。
- 初始化容量为16。
- 扩容条件：当前元素个数 >= 容量*加载因子，此时需要扩容。
- 扩容方式：2倍扩容，保证table.length是2的幂，以保证indexOf方法中按位与操作的准确性。
- 扩容后由于数组长度发生改变，需要重新计算index值并且更新节点（采用单链表的头插法）。
/*
* 扩容函数：resize()
* 2倍扩容始终能够保证table.length是2的幂
* 扩容后需要重新计算hash值，重新更新节点。
*/
public void resize(){
int old_length = table.length;
int new_length = 2 * old_length;
Entry<K,V>[] old_table = table;
table = new Entry[new_length];
//将老数组的元素放到新数组中,需要重新计算每一个元素的下标
for(Entry<K,V> e:old_table){
while(e != null){
Entry<K,V> next = e.next;
int index = indexOf(hash(e.key));
//头插法
e.next = table[index];
table[index] = e;//将头结点更新到e
e=next;//e继续往下走
}
}
}
（6）put()方法
- 函数名：put(K key,V value)
- 函数作用：给HashMap中添加元素
- 参数：key，value
- 返回值类型：void
需要注意的点
对key为空的特殊处理，体现在两个地方。
- hash()算法。（上文已说明）
- if 语句判断key是否相等时，首先判断hash值是否相同，如果hash值相同，不能说明他俩就是同一个key，若不同，则一定不是同一个key。其次判断引用是否相同，引用相同说明他俩相同；引用不同的话判断equals里面的属性值是否相同。
if (e.hash == h && (e.key == key || (key != null && key.equals(e.key)))) {...}
以下为put()方法实现及思路。
/*
* 添加函数：（思路如下）
* 1、如果是第一次添加，将数组容量设置为默认容量
* 2、根据当前数组大小，计算哈希后的index值
* 3、如果要添加的key值与已有key值有重复，则替换value值
* 4、如果不重复，先判断是否需要扩容。（size>table.length*0.75时需要扩容）
* 5、头插法插入链表。
*/
public void put(K key,V value){
if (table == EMPTY_TABLE) { // 是否时第一次添加元素
table = new Entry[DEFAULT_CAPCITY];
}
int h = hash(key);
int index = indexOf(h);//计算key值对应的下标
//e.key.equals(key) 比较速率较慢
for (Entry<K, V> e = table[index]; e != null; e = e.next) {//遍历下标下的链表
if (e.hash == h && (e.key == key || (key != null && key.equals(e.key)))) {//如果key值相同，则值替换
e.value = value;
return; //如果key有重复 值替换掉之后方法就退出
}
}
//代码走到着说明key 没有重复 头插法
if (size >= table.length * threshold) {
resize(); //如何扩容：2倍扩容 始终能够保证table.length是2的幂
index = indexOf(hash(key));
}
//添加数据,之前出错时因为没有传入h的值，导致每个插入的节点没有hash值。
table[index] = new Entry<K,V>(key, value, table[index],h);//不相同则头插
size++;
}
（6）remove()删除方法
- 函数名：remove(K key)
- 函数作用：通过指定key删除元素
- 参数：key
- 返回值类型：布尔类型
思路：
- 计算key的hash值和对应的index下标。
- 循环找出与传入key相同的节点。
- 找到后根据所删节点是否为头结点分情况处理。
- 移动pre（指向当前节点前驱）和e（指向当前节点）两个指针的位置。（pre和e初始位置都指向table[index]）。
public boolean remove(K key){
if (size <= 0) {
return false;
}
int h = hash(key);
int index = indexOf(h);
Entry<K, V> pre = table[index];
Entry<K, V> e = table[index];
while (e != null) {
Entry<K, V> next = e.next;
//第一个循环进来如果判断相等就成立 删除的的就是头节点 pre == e
if (e.hash == h && (e.key == key || (key != null && key.equals(e.key)))) {
size--;
//如果删除的节点是头节点
if (pre == e) { //判断删除的节点就是头节点
table[index] = next;
} else {
pre.next = next;
}
e.next = null;
e.key = null;
e.value = null; //只有指向空之后才能进行垃圾回收
return true;
}
pre = e;
e = next; //pre 变成了e的前驱
}
return false;
}
6、解决哈希冲突的方法：链地址法。
7、常见问题
（1）为什么不直接采用经过hashCode()处理的哈希码 作为 存储数组table的下标位置？
答：保证index一定时小于数组长度。防止数组下标访问越界。
（2）为什么HashMap需要扩容？
答：不是因为没有足够存储空间。扩容之后要重新计算每一个节点对应的index，哈希冲突概率降低。
（3）如果自己指定HashMap的初始容量和加载因子，那么容量的大小，和加载因子的大小对HashMap有什么影响？
- 初始容量：如果我们指定不是2的幂，源码中有函数能够保证将最终数组容量改变到2的幂。向上取整找最近的2的幂。
- 初始容量越小，越容易发生哈希冲突。
- 加载因子 :越大 。对扩容时机有影响。
- 加载因子越大扩容的时机越晚，哈希冲突的几率越大，空间利用率越大。
- 加载因子越小，越大扩容的时机越早，哈希冲突的几率越小，空间利用率越小。
（4）为什么用按位与代替取余？
答：因为位运算的计算效率高于算数计算。
（5）为什么hashmap的容量要保持2的幂？
答：为了用 & (length-1) 代替 % length 。
（6）HashMap中如果添加重复key会怎样？
答：新添加进来的key对应的newvalue代替之前老的value。
8、应用场景
（1）hashMaori查询效率较高，可以通过key值去快速查找value值。
（2）计数。
9、HashTable与HashMap异同
相同点：
- 两者都会根据key重新计算所有元素的存储位置，算法相似，时间空间效率相同。
不同点：
- hashtable默认容量为11，hashmap为16。
- hashtable是在构造函数中初始化并且new对象；hashmap是在put方法中第一次添加数据时。
- hashtable中计算hash方法，hash()，hashSeed^k.hashCode()，没有扰动处理，index重复率会高。
- 计算index下标的方法：（hash & 0x7FFFFFFF）%table.length;保证hash值不为负数，保证index下标不会大于table.length。
- 扩容方式：hashTable是2倍加1，保证结果都是奇数，因为取余之后的结果相比于偶数更分散。tableMap是2倍扩容。
- 数据遍历方式：hashTable可以使用Enumerate和Iterator进行遍历；使用iterator进行遍历时支持快速失败机制。
- 是否是线程安全：hashTable是线程安全的。但并不是绝对的线程安全。由于hashTable效率低已被淘汰，索引多线程环境下会选择ConcurrentHashMap。
- 是否接受值为null的Key 或Value：hashtable中值和value都不能为空。hashmap中key和value都可以为空。