HashMap

72 阅读 0 评论 48 点赞

我是靠谱客的博主英勇八宝粥，最近开发中收集的这篇文章主要介绍HashMap，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1.HashMap的使用：

（1）插入键值对数据

public V put(K key, V value)

（2）根据键值获取键值对值数据

public V get(Object key)

（3）获取Map中键值对的个数

public int size()

（4）判断Map集合中是否包含键为key的键值对

public boolean containsKey(Object key)

（5）判断Map集合中是否包含值为value的键值对

boolean containsValue(Object value)

（6）判断Map集合中是否没有任何键值对

public boolean isEmpty()

（7）清空Map集合中所有的键值对

public void clear()

（8）根据键值删除Map中键值对

public V remove(Object key)

public static void main(String[] args) {
        // 声明HashMap对象
        Map<String,Integer> map= new HashMap<>();

        //添加数据
        map.put("ZhangYi",98);
        map.put("WangEr",99);
        map.put("ZhangShan",89);
        map.put("Lisi",92);

        //根据键值对键值获取数据‘’
        int value=map.get("Lisi");
        System.out.println("kay:Lisi And value:"+value);

        //获取Map中键值对的个数
        int size=map.size();
        System.out.println("map 中的键值对个数为："+size);

        //判断Map集合中是否包含键为key的键值对
        boolean b1=map.containsKey("LiSI");
        boolean b2=map.containsKey("Lisi");
        System.out.println("是否包含键值为LiSI的键值对数据："+b1);
        System.out.println("是否包含键值为Lisi的键值对数据："+b2);

        //判断Map集合中是否包含值为value的键值对
        boolean b3=map.containsValue(99);
        boolean b4=map.containsValue(100);
        System.out.println("是否包含值为99的键值对数据："+b3);
        System.out.println("是否包含值为100的键值对数据："+b4);

        //判断Map集合中是否没有任何键值对

        boolean b5=map.isEmpty();
        System.out.println("map中键值对数据是否为空："+b5);

        //根据键值删除Map中键值对
        int value2=map.remove("Lisi");
        System.out.println("删除了键为Lisi的键值对数据，其值为："+value2);

        boolean b6=map.containsKey("Lisi");
        System.out.println("是否包含键值为Lisi的键值对数据："+b6);

        //清空Map集合中所有的键值对
        map.clear();
        boolean b7=map.isEmpty();
        System.out.println("map中键值对数据是否为空："+b7);

    }
}

运行结果：

kay:Lisi And value:92
map 中的键值对个数为：4
是否包含键值为LiSI的键值对数据：false
是否包含键值为Lisi的键值对数据：true
是否包含值为99的键值对数据：true
是否包含值为100的键值对数据：false
map中键值对数据是否为空：false
删除了键为Lisi的键值对数据，其值为：92
是否包含键值为Lisi的键值对数据：false
map中键值对数据是否为空：true

HashMap迭代器的使用：

*HashMap遍历方式：

1）Key的遍历：

HashMap<Integer,String> map= new HashMap<>();

        //添加数据
        map.put(12,"ZhangYi");
        map.put(23,"WangEr");
        map.put(14,"ZhangShan");
        map.put(45,"Lisi");

for(Integer key:map.keySet()){
    System.out.print("key:"+ key);
    System.out.print("value:" +map.get(key));
}

2)value的遍历：

HashMap<Integer,String> map= new HashMap<>();

        //添加数据
        map.put(12,"ZhangYi");
        map.put(23,"WangEr");
        map.put(14,"ZhangShan");
        map.put(45,"Lisi");

for(String str: map.values()){
    //map中的key不可以重复，但是value可以重复
    System.out.print("value: " +str);
}

3)Entry的遍历：

HashMap<Integer,String> map= new HashMap<>();

        //添加数据
        map.put(12,"ZhangYi");
        map.put(23,"WangEr");
        map.put(14,"ZhangShan");
        map.put(45,"Lisi");

    //entrySet得到当前HashMap中节点的集合
for(Map.Entry<Integer,String> entry: map.entrySet()){
    System.out.println("key: " +entry.getKey()+"value: "+entry.getValue());
}

4)Interator遍历：

HashMap<Integer,String> map= new HashMap<>();

        //添加数据
        map.put(12,"ZhangYi");
        map.put(23,"WangEr");
        map.put(14,"ZhangShan");
        map.put(45,"Lisi");

Iterator<Map.Entry<Integer,String>> itr = map.entrySet().iterator();
while(itr.hasNext()){
    Map.Entry<Integer,String> entry = itr.next();
    System.out.println("key: "+entry.getKey()+"value: "+entry.getValue());
}

2.HashMap的底层源码实现：

2.1.HashMap中put()方法：

public V put(K key, V value) {
/**四个参数，第一个hash值，第四个参数表示如果该key存在值，如果为null的话，则插入新的value，最后一个参数，在hashMap中没有用，可以不用管，使用默认的即可**/
return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab 哈希数组，p 该哈希桶的首节点，n hashMap的长度，i 计算出的数组下标
Node<K,V>[] tab; Node<K,V> p; int n, i;
//获取长度并进行扩容，使用的是懒加载，table一开始是没有加载的，等put后才开始加载
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/**如果计算出的该哈希桶的位置没有值，则把新插入的key-value放到此处，此处就算没有插入成功，也就是发生哈希冲突时也会把哈希桶的首节点赋予p**/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//发生哈希冲突的几种情况
else {
// e 临时节点的作用， k 存放该当前节点的key
Node<K,V> e; K k;
//第一种，插入的key-value的hash值，key都与当前节点的相等，e = p，则表示为首节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//第二种，hash值不等于首节点，判断该p是否属于红黑树的节点
else if (p instanceof TreeNode)
/**为红黑树的节点，则在红黑树中进行添加，如果该节点已经存在，则返回该节点（不为null），该值很重要，用来判断put操作是否成功，如果添加成功返回null**/
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//第三种，hash值不等于首节点，不为红黑树的节点，则为链表的节点
else {
//遍历该链表
for (int binCount = 0; ; ++binCount) {
//如果找到尾部，则表明添加的key-value没有重复，在尾部进行添加
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//判断是否要转换为红黑树结构
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
//如果链表中有重复的key，e则为当前重复的节点，结束循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//有重复的key，则用待插入值进行覆盖，返回旧值。
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//到了此步骤，则表明待插入的key-value是没有key的重复，因为插入成功e节点的值为null
//修改次数+1
++modCount;
//实际长度+1，判断是否大于临界值，大于则扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
//添加成功
return null;
}

2.2.HashMap之resize()方法

当插入数据时哈希表过于拥挤,即size>threshold 或者table == null时，会
触发一次resize扩容操作。扩容时，我们的内部数组扩容了2倍，所以对于每
一个插槽内的元素在 rehash时存在两种可能：
1.依然映射到当前下标插槽处
2.映射到高位下标处(当前下标 + 扩容前内部数组长度大小)
final Node<K,V>[] resize() {
//oldTab指向hash桶数组
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//如果oldCap不为空，即hash桶数组不为空
if (oldCap > 0) {
//判断oldCap是否大于最大容量，如果大于最大容量了，就赋值为整数的最大值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
//直接返回
return oldTab;
}
//如果当前hash桶数组的长度在扩容后仍然小于最大容量，这里扩容指的是以2倍的方式扩容，并且oldCap大于默认值16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//双倍扩容阀值
newThr = oldThr << 1; // double threshold
}
//反之，oldCap小于等于0，但是oldThr大于0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//oldCap小于等于0，oldThr小于等于0
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})

//新建hash数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//使得旧数组的引用指向新数组
table = newTab;
//进行扩容操作，即复制节点对象到新的hash桶数组中
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果旧数组在j位置不为空，将该节点赋值给e
if ((e = oldTab[j]) != null) {
//将旧数组中j位置设置为空，方便gc
oldTab[j] = null;
//如果e后面没有节点
if (e.next == null)
//直接对e的hash值按位与新数组的长度得到index位置，将e节点放置该位置
newTab[e.hash & (newCap - 1)] = e;
//如果e为红黑树的节点类型，那么添加到红黑树中
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//反之e为链表的节点类型，并且e.next != null
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
//将当前节点的next赋值给next引用
next = e.next;
//如果节点e的hash值与原hash桶数组的长度按位与为0
//若与原容量按位与，结果为0，表示将这个节点放入新数组中，位置不变
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//如果节点e的hash值与原hash桶数组的长度按位与不为0
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//如果loTail不为空
if (loTail != null) {
//将loTail.next设置为空
loTail.next = null;
//将loHead赋值给新的hash桶数组j位置
newTab[j] = loHead;
}
//如果hiTail不为空
if (hiTail != null) {
//将hiTail.next设置为空
hiTail.next = null;
//将hiHead赋值给新的hash桶数组[j+旧hash桶数组的长度]
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}

2.3.HashMap之get(Object key)方法

public V get(Object key) {
Node<K,V> e;
//getNode得到该key所对应的节点e，节点为null则返回null,反之返回e.value
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//判断当前table(桶)不能为空，即桶中存在节点，并且当前key-》index不为空，即该位置存在节点
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//判断该位置的第一个节点(first),如果first.hash等于该key所对应的散列码，first.key等于该key，则直接返回first
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//判断当前first.next后是否存在其他节点，如果存在即first.next != null
if ((e = first.next) != null) {
//判断该first节点是否是红黑树节点，如果是，则调用红黑树中getTreeNode方法
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//do-while循环特点是先执行循环体，再判断条件是否满足
//e为当前节点，如果e.hash等于key所对应的散列码，e.key等于该key，则直接返回e
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}

2.4.HashMap之remove(Object key)方法

public V remove(Object key) {
Node<K,V> e;
//remove删除该key所对应的节点e，节点为null则返回null,反之返回e.value
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//判断当前table(桶)不能为空，即桶中存在节点，并且当前key-》index不为空，即该位置存在节点
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
//p为该位置的第一个节点，如果p.hash等于该key所对应的散列码，p.key等于该key，则p为目标节点，赋值给node引用
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
//判断当前p.next后是否存在其他节点，如果存在即p.next != null
else if ((e = p.next) != null) {
//判断该p节点是否是红黑树节点，如果是，则调用红黑树中getTreeNode方法得到该节点，赋值给node引用
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//反之为链表节点，在该链表中查找到该节点，赋值给node引用
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//判断该node节点是否是红黑树节点，如果是则调用红黑树中的removeTreeNode方法
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果node == p, 说明目标删除节点为第一个节点
else if (node == p)
tab[index] = node.next;
//反之，p为目标删除节点的前一个节点，node为目标删除节点，p.next = node.next
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}

3.HashMap迭代器实现：

abstract class HashIterator {
//要返回的下一个节点
Node<K,V> next; // next entry to return
//当前节点
Node<K,V> current; // current entry
//期望的结构性修改次数
int expectedModCount; // for fast-fail
//索引位置
int index; // current slot

//HashIterator构造器
HashIterator() {
//期望的结构性修改次数赋值
expectedModCount = modCount;
//当前HashMap中table赋值给t
Node<K,V>[] t = table;
current = next = null;
index = 0;
//查找当前哈希表中第一个非空的数据节点赋值给next
if (t != null && size > 0) { // advance to first entry
do {} while (index < t.length && (next = t[index++]) == null);
}
}

//判断当前迭代器是否含有下一个可迭代的元素
public final boolean hasNext() {
return next != null;
}

//返回当前可迭代器的下一个元素
final Node<K,V> nextNode() {
Node<K,V>[] t;
//next保存当前可迭代的下一个元素，将next赋值给e
Node<K,V> e = next;
//不相等，说明在迭代器迭代的过程中HashMap结构发生变化，则抛出异常
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
//当前下一个可迭代元素不为空并且table也不为空
if ((next = (current = e).next) == null && (t = table) != null) {
//查找当前哈希表中下一个非空的数据节点赋值给next

do {} while (index < t.length && (next = t[index++]) == null);
}
//返回结果
return e;
}

public final void remove() {
//current节点为上一次next返回的节点
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
//调用HashMap中removeNode(hash, key, value, mathchValue, movable)删除当前key所在节点;
removeNode(hash(key), key, null, false, false);
//更新expectedModCount为最新值
expectedModCount = modCount;
}
}

4.HashMap与HashTable之间的区别与联系：

4.1.继承的父类不同：
Hashtable继承 Dictionary ， HashMap继承AbstractMap
他们二者都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口

4.2.默认容量：
Hashtable为11 HashMap为16

4.3.Table的初始化时机：
Hashtable 构造函数中初始化，HashMap 第一次put

4.4.并发操作：
Hashtable使用同步机制，
实际应用程序中，仅仅是Hashtable本身的同步并不能保证程序在并发操作下的正确性，需要高层次的并发保护。
下面的代码试图在key所对应的value值等于x的情况下修改value为x+1
{
value = hashTable.get(key);
if(value.intValue()== x){
hashTable.put(key, new Integer(value.intValue()+1));
}
}
如2个线程同时执行以上代码，可能放入不是x+1，而是x+2.
HashMap没有同步机制，需要使用者自己进行并发访问控制

4.5.数据遍历的方式：
Hashtable Iterator 和 Enumeration ， HashMap Iterator

4.6.是否支持fast-fail：
Hashtable 用Iterator遍历，支持fast-fail，用Enumeration不支持fast-fail. ， HashMap 支持fast-fail

4.7.是否接受值为null的Key 或Value？
Hashtable 不接受， HashMap接受

4.8.根据hash值计算数组下标的算法：
Hashtable 当数组长度较小，并且Key的hash值低位数值分散不均匀时，不同的hash值计算得到相同下标值的几率较高
hash = key.hashCode();
index=(hash&0x7FFFFFFF) % tab.length;//去掉其符号位置
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
hash = hash (k);
index = indexFor(hash, table.length);
static int hash(Object x) {
int h = x.hashCode();
h += ~(h << 9);
h ^= (h >>> 14);
h += (h << 4);
h ^= (h >>> 10);
return h;
}把后面几位移动到前面
static int indexFor(int h, int length) {
return h & (length-1);
}
HashMap优于hashtable，通过对Key的hash做移位运算和位的与运算，使其能更广泛地分散到数组的不同位置

4.9.Entry数组的长度：
Hashtable的缺省初始长度为11，初始化时可以指定initial capacity
HashMap的缺省初始长度为16，长度始终保持2的n次方初始化时可以指定initial capacity，若不是2的次方，HashMap将选取第一个大于initial capacity 的2n次方值作为其初始长度

4.10.LoadFactor负荷因子：
Hashtable和HashMap都是0.75

4.11.负荷超过（loadFactor * 数组长度）时，内部数据的调整方式：
Hashtable的扩展数组：2*原数组长度+1 ，HashMap的扩展数组：原数组长度 * 2
两者都会重新根据Key的hash值计算其在数组中的新位置，重新放置。算法相似，时间、空间效率相同