我从未见过如此精辟的解说方式，双列集合框架 Map，看一遍就够了

1.经常使用的实现类结构

1、HashMap

实现了Map、Cloneable、Serializable接口，继承了AbstractMap类

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable     
    /**
     * Map接口: 实现键值对,Map接口规定了一个key对应一个value
     *          HashMap使用该接口用来替换Dictionary类
     *
     * AbstractMap类: 继承Map的抽象类,减小Map操做的实现
     *
     * Cloneable接口: 能够显示的调用Object.clone()方法,合法的对该类
     *                实例进行字段复制
     *
     * Serializable接口: 实现该接口后,该类能够被序列化和反序列化
     */

1.HashMap是否线程安全？

HashMap是线程不安全的，在并发的环境下可使用ConcurrentHashMap。

2.HashMap的内部实现

内部实现：在JDK1.8以前是数组+链表，JDK1.8以后是数组+链表+红黑树
加入红黑树的缘由:JDK1.8以前HashMap使用的是数组加链表，因为哈希函数不能百分百的让元素均匀的分布，就会形成有大量的元素存入同一个index（桶）下，这样index就造成了一条很长的链表，由此元素的遍历的时间复杂度为O(n),失去了HashMap的优点，加入了红黑树，查找的时间复杂度为O(log n),实现了优化
数组的特色：查找快，时间复杂度是O(1),增删慢，时间复杂度是O(n)
链表的特色：查找慢，时间复杂度是O(n),增删快，时间复杂度是O(1)
红黑树的特色：在遍历链表的基础上，红黑树查找的时间复杂度是O(log n)
红黑树的查询效率远大于链表，可是插入/删除要比链表慢

3.HashMap的主要参数

1.默认初始容量：16，必须是2的整数次方

2.默认加载因子：0.75

3.阈值：容量*加载因子

4.树形阈值：默认是8，当bucket中的链表长度大于8时，则进行链表树化

5.非树形阈值：默认是6，当进行扩容时，当进行扩容（resize（））时（这时候的HashMap的数据存储位置会从新计算），在计算完后，原有的红黑树内的数量<6时，则由红黑树转换为链表

6.树形最小容量：桶多是树的哈希表的最小容量，至少是TREEIFY_THRESHOLD 的 4 倍，这样能避免扩容时的冲突

//链表转红黑树的阈值
static final int TREEIFY_THRESHOLD = 8;
//红黑树转链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
/**
*最小树形化容量阈值：即 当哈希表中的容量 > 该值时，才容许树形化链表 （即 将链表 转换成红黑树）
*不然，若桶内元素太多时，则直接扩容，而不是树形化
*为了不进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
**/
static final int MIN_TREEIFY_CAPACITY = 64;

只有在数组的长度大于64时，且链表的长度>8时，才能树形化链表
链表的长度大于8时会调用treeifyBin方法转换为红黑树，可是treeifyBin方法内部有一个判断，当只有数组的长度>64的时候，才能将链表树形化，不然只进行resize扩容
由于链表过长而数组太短，会常常发生hash碰撞，这时进行树形化的做用不大，由于链表过长的缘由就是数组太短。树形化以前要检查数组的长度，<64进行扩容，而不是进行树形化
链表的长度>8，但数组的长度<64时,不会进行树形化，而是进行resize后rehash从新排序

4.HashMap的经常使用方法

添加：V put(K key,V value) -->添加元素（也能够实现修改）

删除：void clear() -->清空全部键值对元素

​ V remove(Object key) -->根据键删除对应的值，并把值返回

判断：containsKey(Object key) -->是否包含指定的键

​ containsValue(Object value)–>是否包含指定的值

遍历：Set<Map.Entry<K,V>> entrySet()–>获取键值对

​ V get(Object key) -->根据键获取值

​ Collection value()–>获取值的集合

获取：Set setKey()–>获取键的集合

​ int size()–>获取集合元素的个数

基本方法的使用

HashMap<Integer,String> map=new HashMap<>();
        //添加元素
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        //键不可重复，值被覆盖
        map.put(3, "C");
        
        //经过键删除整个键值对
        map.remove(3);
        //清空
        map.clear();
        //是否为空
        System.out.println(map.isEmpty());//false
        //是否包含4
        System.out.println(map.containsKey(4));//false
        //是否包含“b”值
        System.out.println(map.containsValue("b"));//true
        //获取集合元素个数
        System.out.println(map.size());//3
        //经过键获取值
        System.out.println(map.get(3));//C
        //获取全部值构成的集合
        Collection<String> values=map.values();
        for(String v:values){
            System.out.println("值:"+v);//值：a    值：b   值：c
        }
        
        System.out.println(map);
    }

两种遍历方式

public static void main(String[] args) {
    Map<String,Integer> map=new HashMap<>();
    map.put("小林",21);
    map.put("小张",35);
    map.put("小王",18);
    demo1(map);
    demo2(map);
  }
  //经过Set<K>  setKey()方法遍历
  private static void demo1(Map<String,Integer> map) {
    Set<String> keys=map.keySet();
    for (String key:keys){
      Integer value=map.get(key);
      System.out.println("键为："+key+"值为："+value);//键为：小林值为：21
                                                      //键为：小王值为：18
                                                      //键为：小张值为：35
    }
  }
  //经过Set<Map.Entry<K,V>> entrySet()方法遍历
  private static void demo2(Map<String, Integer> map) {
    Set<Map.Entry<String,Integer>> kvs=map.entrySet();
    for (Map.Entry<String,Integer> kv:kvs){
      String kstring=kv.getKey();
      Integer istring=kv.getValue();
      System.out.println(kstring+"-----"+istring);
      //小林-----21
      //小王-----18
      //小张-----35
    }
  }

5.关于hash冲突问题

1.缘由：

​ 当对某个元素进行哈希运算后，获得一个存储地址，在进行插入的时候，发现已经被其余元素占用了。这就是所谓的哈希冲突，也叫哈希碰撞。

哈希函数的设计相当重要，好的哈希函数会尽可能的确保计算简单和散列地址分布均匀，可是，数组是一块连续的固定的长度的内存空间，再好的哈希函数也不能保证获得的存储地址绝对不发生冲突。
2.解决hash冲突的方法：

开放地址法：发生冲突，继续寻找下一块未被占用的存储地址。
再散列函数法：当发生冲突，使用第二个、第三个、哈希函数计算地址，直到无冲突。
链地址法：将全部关键字的同义词的记录存储在一个单链表中，咱们称这种表为同义词子表。
HashMap采用的是链地址法，也就是数组+链表的方式

HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，若是定位到的数组位置不含链表（当前的entry的next指向null），那么对于查找，添加等操做很快，仅需一次寻址便可；若是定位到的数组包含链表，对于添加操做，其时间复杂度为O(n),首先遍历链表，存在即覆盖，不然新增，而后经过key对象的equals方法逐一比对查找。因此！对于性能考虑，HashMap中的链表出现越少，性能才会越好。

6.JDK1.8以前HashMap存在死循环的问题

缘由：因为数组扩容后，同一索引位置的节点顺序会反掉

7.HashMap和Hashtable的区别

8.重写equals()方法后，是否必定要重写hashCode()方法？为何？

重写equals()方法，须要重写hashCode()方法。

hashCode规定：两个对象相等（即equals()返回true），hashCode必定相同；两个对象hashCode相同，两个对象不必定相等；

重写equals，而不重写hashCode方法，默认调用的是Object类的hashCode()方法，会致使两个对象的equals相同但hashCode不一样。简单的来讲，重写equals方法后，重写hashCode方法就是为了确保比较的两个对象是同一对象。

2、LinkedHashMap

LinkedHashMap的底层结构和HashMap是相同的，由于LinkedHashMap继承了HashMap，

区别在于：LinkedHashMap内部提供了Entry，替换了HashMap中的Node。

LinkedHashMap：保证在遍历map元素时，能够照添加的顺序实现遍历

缘由：在原来的HashMap底层结构的基础上，增长了一对指针，指向前一个和后一个元素

对于频繁的遍历操做，LinkedHashMap的效率要高于HashMap

3、TreeMap

保证照key-value对进行排序，实现排序遍历，此时考虑key的天然排序或者定制排序，底层使用的是红黑树

元素根据键排序，元素具备惟一性

1）天然排序

让元素所在的类继承天然排序Comparable

2）比较器排序

让集合的构造方法接收一个比较器接口（Comparator的实现对象）

4、Hashtable

做为古老的实现类；线程安全的，效率低；不能存储null的key和value

最后

你们看完有什么不懂的能够在下方留言讨论，也能够关注我私信问我，我看到后都会回答的。也欢迎你们关注个人公众号：前程有光，金三银四跳槽面试季，整理了1000多道将近500多页pdf文档的Java面试题资料，文章都会在里面更新，整理的资料也会放在里面。谢谢你的观看，以为文章对你有帮助的话记得关注我点个赞支持一下！