Map map = new HashMap((int initialCapacity, float loadFactor)；

简介

HashMap是无序，非线程安全基于哈希表的键值对集合

数据结构

底层采用数组，链表，红黑树的数据结构实现

特点

效率高，读取快，允许存null，但key不能重复。

关键参数

/**实际存储的key-value键值对的个数*/
transient int size;

/**阈值，当table == {}时，该值为初始容量（初始容量默认为16）；当table被填充了，也就是为table分配内存空间后，
threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold，后面会详细谈到*/
int threshold;

/**负载因子，代表了table的填充度有多少，默认是0.75
加载因子存在的原因，还是因为减缓哈希冲突，如果初始桶为16，等到满16个元素才扩容，某些桶里可能就有不止一个元素了。
所以加载因子默认为0.75，也就是说大小为16的HashMap，到了第13个元素，就会扩容成32。
*/
final float loadFactor;

/**HashMap被改变的次数，由于HashMap非线程安全，在对HashMap进行迭代时，
如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），
需要抛出异常ConcurrentModificationException*/
transient int modCount;

存入过程(put)

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

首先，HashMap<String, Integer> hashMap = new HashMap();当创建 HashMap 集合对象的时候，HashMap 的构造方法并没有创建数组，而是在第一次调用 put 方法时创建一个长度是16 的数组(即，16个桶) ，Node[] table?（jdk1.8 之前是 Entry[] table）用来存储键值对数据。

然后，当我们放一个键值对进去时候，如果桶长度为0，则创建桶。

第二，计算key的hashcode值，通过位运算用hashcode值除桶大小tab[i = (n - 1) & hash]) 取余找到放置位置(底层实际还存在优化过程)。

第三 ，如果放置位置为空则直接放入，放入后判断如果++size (键值对个数)> threshold(阈值)(++键值对总个数>桶大小*负载因子)则进行扩容至之前桶大小的两倍，然后从新计算放置键值对。

第四，如果放置位置不为空，节点上有key相同的话直接覆盖，重复上一步操作

第五，如果放置位置没有重复key，则判断节点是否是树节点，如果不是树节点，则遍历链表插入，如果插入后当前链表长度大于8且桶大小大于64.，则把当前链表转成红黑树，最后如果++size (键值对个数)> threshold(阈值)(++键值对总个数>桶大小*负载因子)则进行扩容至之前桶大小的两倍，然后从新计算放置键值对。

第六，如果是树节点，则直接插入进红黑树，最后如果++size (键值对个数)> threshold(阈值)(++键值对总个数>桶大小*负载因子)则进行扩容至之前桶大小的两倍，然后从新计算放置键值对。

注意事项

       

  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;
        this.threshold = tableSizeFor(initialCapacity);
    }

 1.桶容量 必须大于0且小于1073741824(2的30次方)。

 2.当我们自定义容量时会自动转成最接近且大于自定义容量的一个2的n次方容量。(比如自定义3则容量为2的2次方为4)。

3.只有当桶容量大于64且链表长度大于8时才会转红黑树 参考treeifyBin方法。为了高效查询。

4.桶容量就是数组长度。size是键值对值总个数。扩容一次增加为之前的2倍大小。16>>32

遍历方法

       

         

            

             

     遍历性能分析

拓展

         对于HashMap无序，非线程安全的问题，

        Map接口下有两个实现解决，

        Hashtable集合底层也是哈希表数据结构，是线程安全的，其中所有的方法都带synchronized关键字，但效率较低，使用一把锁处理并发问题，当有多个线程访问时，需要多个线程竞争一把锁，容易导致阻塞。现在使用较少了，我们可以用ConcurrentHashMap替代，            ConcurrentHashMap线程安全，效率高，采用分段锁实现，从JDK1.7版本的ReentrantLock+Segment+HashEntry，到JDK1.8版本中synchronized+CAS+HashEntry+红黑树的底层实现使之在多线程下效率高。

        TreeMap集合底层的数据结构是一个二叉树 ，是一个有序集合，我们一般用LinkedHashMap替代。

       LinkedHashMap继承自HashMap。使用Map接口的哈希表和链表实现，具有可预知的迭代顺序。此实现与HashMap的不同之处在于：LinkedHashMap维护着一个双向循环链表。此链表定义了迭代顺序，该迭代顺序通常就是存放元素的顺序。遍历速度比HashMap慢。

    关系图