浅谈HashMap

weixin_37568802

于 2019-10-12 11:38:56 发布

阅读量68

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/weixin_37568802/article/details/102517460

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

HashMap继承AbstractMap抽象类

AbstractMap实现Map接口

HashMap是非线程安全的，只是用于单线程环境下，多线程环境下可以采用concurrent并发包下的concurrentHashMap。

HashMap内部维护了一个存储数据的Entry数组，HashMap采用链表解决冲突，每一个Entry本质上是一个单向链表。当准备添加一个key-value对时，首先通过hash(key)方法计算hash值，然后通过indexFor(hash,length)求该key-value对的存储位置，计算方法是先用hash&0x7FFFFFFF后，再对length取模，这就保证每一个key-value对都能存入HashMap中，当计算出的位置相同时，由于存入位置是一个链表，则把这个key-value对插入链表头。

HashTable和HashMap区别

1、继承的父类不同

Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。

2、线程安全性不同

HashMap非线程安全，HashTable为线程安全。

PS：线程安全效率会低，所以项目中非多线程推荐使用HashMap；

从源码角度分析：
HashMap构造方法如下：

public HashMap() {
 this.loadFactor = DEFAULT_LOAD_FACTOR; 
}
static final float DEFAULT_LOAD_FACTOR = 0.75f;

初始化赋值了一个0.75f，指的是存储空间占大于总空间的0.75倍会进行扩容。

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
 int oldCap = (oldTab == null) ? 0 : oldTab.length;
 int oldThr = threshold;
 int newCap, newThr = 0;
 if (oldCap > 0) {
 if (oldCap >= MAXIMUM_CAPACITY) {
 threshold = Integer.MAX_VALUE;
 return oldTab;
        }
 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
 }
 else if (oldThr > 0) // initial capacity was placed in threshold
 newCap = oldThr;
 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"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
 table = newTab;
 if (oldTab != null) {
 for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
 if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
 if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
 else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
 else { // preserve order
 Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
 do {
                        next = e.next;
 if ((e.hash & oldCap) == 0) {
 if (loTail == null)
                                loHead = e;
 else
 loTail.next = e;
                            loTail = e;
                        }
 else {
 if (hiTail == null)
                                hiHead = e;
 else
 hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
 if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
 if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
 return newTab;
}

这段话是说初始化或加倍表大小。如果为空，则分配与初始容量目标保持一致。否则，因为我们使用的是二次展开的幂，所以每个bin中的元素必须保持在同一索引中，或者移动

在新表中使用两个偏移量的幂。（简单来说，就是hashmap必须是2的多少次幂的内存）

我们来看几个常用的方法：

public void clear() {
    Node<K,V>[] tab;
 modCount++;
 if ((tab = table) != null && size > 0) {
 size = 0;
 for (int i = 0; i < tab.length; ++i)
            tab[i] = null;
    }
}

删除操作，判断不为0，然后循环赋null

public boolean containsValue(Object value) {
    Node<K,V>[] tab; V v;
 if ((tab = table) != null && size > 0) {
 for (int i = 0; i < tab.length; ++i) {
 for (Node<K,V> e = tab[i]; e != null; e = e.next) {
 if ((v = e.value) == value ||
                    (value != null && value.equals(v)))
 return true;
            }
        }
    }
 return false;
}