再探Java集合系列

前面我们已经针对LinkedList和ArrayList的底层原理进行了具体研究讨论，大家可以跳链接阅读哦~

再探Java集合系列—ArrayList-CSDN博客

再探Java集合系列—LinkedList-CSDN博客

HashMap有哪些特征呢？

value可以重复，key不能重复，允许null键和null值（如果新添加key-value的Map中已经存在重复的key，那么新添加的value就会覆盖该key原来对应的value）
不能保证key-value对的顺序
如果添加相同的key，则会覆盖原来的key-val，等同于修改
没有实现同步，因此线程不安全，方法没有做同步互斥操作，

如何使用HashMap呢？

Map<k,v> map =new HashMap<k,v>();

Map是一种键-值对（key-value）集合，Map中每一个元素都包含一个键对象和一个值对象。

元素：键-值对整体

因为Map中的key和value是不允许使用基本类型的，那为什么呢？

Java中的基本类型和包装类型之间存在自动装箱（autoboxing）和拆箱（unboxing）的过程。当我们将基本类型的值放入Map中时，Java会自动将其转换为对应的包装类型；当我们从Map中取出包装类型的值时，Java会自动将其转换为对应的基本类型。这个过程会带来一些性能上的损耗，特别是在大量数据操作时

Map有哪些方法？

put（key,value):添加数据
get（key,value)：根据key取值
containsKey（key）：判断当前的map集合是否包含指定的key
containsValue（value）：判断当前的map集合是否包含指定的value
clear：清空集合
keySet():获取map集合的key的集合
values():获取集合的所有value的值
for(String key:keys)：遍历map集合

实战演练

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapTest {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String,Integer>();
        //添加数据
        map.put("b",1);
        map.put("c",2);
        map.put("e",2);
        System.out.println(map);   //输出结果：{b=1, c=2, e=2}

        //根据key取值
        System.out.println(map.get("b")); //输出结果：1

        //根据key移除键值对
        map.remove("c");
        System.out.println(map);  //输出结果：{b=1, e=2}

        //map集合的长度
        System.out.println(map.size());  //输出结果：2

        //判断当前的map集合是否包含指定的key
        System.out.println(map.containsKey("b"));  //输出结果：true
        //判断当前的map集合是否包含指定的Value(书写敏感，加双引号和不加双引号的区别)
        System.out.println(map.containsValue(1));  //输出结果:true
        System.out.println(map.containsValue("1"));  //输出结果:false

        //清空集合
        //map.clear();

        //获取map集合的key的集合
        map.keySet();
        //获取集合的所有value值
        map.values();


        //获取map集合的key的集合
        Set<String> keys = map.keySet();
        //遍历map集合
        // 第一种方式：for循环
        for(String key:keys){
            System.out.println("key:"+key+",value:"+map.get(key));
        }

       //第二种方式：通过map.entrySet();遍历map集合
        Set<Map.Entry<String,Integer>> entrys = map.entrySet();
        for (Map.Entry<String,Integer> en:entrys){
            System.out.println("key:"+en.getKey()+",value:"+en.getValue());
        }
    }
}

数据结构

jdk1.8前：数组+链表无序，头插

jdk1.8 ：数组+链表+红黑树无序，尾插

底层原理

实例化HashMap

在创建HashMap对象的时候知识初始化一些参数

为什么默认初始容量为16？

匹配硬件设计

大量数据测试，确定基本参数配置

增加元素—put

（图片来源于网上）

当我们在put添加元素的时候，当多个元素映射到了同一个位置，hashmap中采用单链表的形式链接每一个元素，在jdk7使用头插法，jdk8开始使用尾插法，同一个位置会将要插入的新元素放在链表的头部。并且总是会判断当前table的容量是否满足可使用范围

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;  //n为table容量，i为下标           
    
        if ((tab = table) == null || (n = tab.length) == 0)   //如果table为null  或者  table长度==0
            n = (tab = resize()).length;  //进行第一次扩容，n为第一次扩容后的table长度
    
        if ((p = tab[i = (n - 1) & hash]) == null)   //计算节点要插入的位置，如果p为null表示这个位置为空，则创建一个新节点插入
            tab[i] = newNode(hash, key, value, null);   //在table表的置顶索引位置处插入新节点
        else {  //否则，说明要映射的索引位置已经存在了元素
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))  
                //判断要插入的节点是否已存在，如果存在则直接覆盖原来的key-value
                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   //判断该链表长度是大于8则转换为红黑树进行处理
                            treeifyBin(tab, hash);
                        break;
                    }

                    //如果key已经存在则直接覆盖value
                    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;
    }