Map：双列数据，储存key-value对的数据。实现map集合有四个实现类。

HashMap

LinkedHashMap

TreeMap

Hashtable

ConcurrentHashMap

线程不安全，效率高，无序的

HashMap的子类，线程不安全，效率高 ，有序的

有序的（默认情况下实现了比较器），查询效率高于HashMap

map的古老实现类，线程安全，效率低

Hashtable的新型替代者，线程安全，效率比Hashtable高

能储存null的key和value

能储存null的key和value

不能能储存null的key和value

不能能储存null的key和value

可以按添加顺序遍历，因为在HashMap基础上，添加了指向前和后的指针，对于频繁遍历，效率高于HashMap

可以使用自然排序或者定制排序，底层是红黑树

和Hashtable、Collections.SynchronizedMap()相比效率高很多，因为是分段加锁

HashMap起始长度16，加载因子0.75，每次扩容为原来的2倍
Hashtable 起始长度11，加载因子0.75

  1. HashMap 的底层：数组+链表（jdk7及以前）
                                   数组+链表+红黑树（jdk8）
  2. Map结构的理解：
    一个键值对：key-value构成了一个entry对象
  • Map中的key：无序的、不可重复的，使用Set存储所有的key —>key所在的类需要重写equals()和hashCode()(以HashMap为例)
  • Map中的value：无序的、可重复的，使用Collection存储所有的value—>value所在的类要重写equals()
  • Map中的entry：无序的、不可重复的，使用Set存储所有的entry
  1. HashMap的底层实现原理：（重点）
    jdk7中：
    HashMap map=new HashMap();
    在实例化以后，底层创建了长度为16的一维数组Entry[] table。
    …可能已经执行了多次put…
    map.put(key1,value1);
    首先，调用key1所在类的hashCode()计算key1的哈希值，此哈希值经过某种算法计算后（底层是&运算），得到了Entry数组中的存放位置。
    如果此位置上的数据为空，此时的key1-value1添加成功。----情况1
    如果此位置上的元素不为空，（意味着此位置上存在一个或多个数据（以链表的形式存在）），比较key1和已经存在的一个或多个数据的哈希值：
              如果key1的哈希值与已经存在的数据的哈希值都不相同，此时的key1-value1添加成功。----情况2
              如果key1的哈希值和已经存在的某一个数据的（key2-value2）的哈希值相同，继续比较：调用key1所在类的equals(key2)方法。
                        如果equals()方法返回false：此时的key1-value1添加成功。----情况3
                        如果equals()方法返回true：使用value1替换value2.

补充：关于情况2和情况3：此时的key1-value1和原来的数据以链表的方式存储。

在不断添加的过程中，会涉及到扩容的问题，默认的扩容方式：扩容为原来的两倍，并将原有的数据复制过来。这时候会重新计算原来的那些数据，将他们重新以某种算法计算后（底层是&运算），重新分配位置。

jdk8相较于jdk7在底层实现方面的不同：

  1. new HashMap()：底层没有创建一个长度为16的数组
  2. jdk8底层的数组是：Node[]，而非Entry[]（里面东西一样，换了个皮）
  3. 首次调用put()方法时，底层创建长度为16的数组
  4. jdk7底层结构只有：数组+链表；jdk8中的底层结构：数组+链表+红黑树
  5. 7上8下。在jdk7的时候，元素a放到数组中，指向原来的元素。
    在jdk8的时候，原来的元素在数组中，指向元素a（详情见下图）。

扩容以及转换成红黑树的条件：

转换成红黑树的条件：当数组的某一个索引位置上的元素以链表形式存在的数据个数 >8 且当前数组长度 > 64时，此时此索引位置上的所有数据改成使用红黑树存储。

扩容有关的：
DEFAULT INITIAL_ CAPACITY: Hashmap的默认容量：16
DEFAULT_LOAD_ FACTOR: HashMap的默认加载因子：0.75
threshold：扩容的临界值，=容量*加载因子：16 * 0.75=>12
TREETFY_ THRESHOLD: Bucket中表长度大于该默认值，转化为红黑树：8
MIN_TREEIFY_CAPACITY：桶中Node被树化时最小的hash表容量：64
由上面在源码中的值可以看出，当数组中的元素到达12个时，就要开始扩容了，默认的加载因子是大数据计算出来的。太小了，数组很容易就需要扩容；太大了，有些地方可能永远用不到，链表就会过长。

  1. Map中的方法：
  • 增：put(key,value)   putAll(Map m)
  • 删：remove(key)   clear()//清空
  • 改：put(key,value)
  • 查：get(key)   containsKey(key)   containsValue(value)   isEmpty()
  • 长度：size()
  • 遍历：keySet()  /  values()  /   entrySet()

增、删、改：
可以看到HashMap并不能按照我们添加的顺序输出，但是它的子类LinkedHashMap可以。

Map map1=new HashMap();
        //增  put（添加一个元素）
        map1.put(11,1);
        map1.put("a1",2);
        map1.put(12,3);
        map1.put("a2",4);
        System.out.println(map1);  //{a1=2, a2=4, 11=1, 12=3}
        //增  putAll（将一个map集合添加到另外一个map集合）
        Map map2=new HashMap();
        map2.putAll(map1);
        System.out.println(map2);  //{a1=2, a2=4, 11=1, 12=3}
        //删  remove（删除一个元素）
        map1.remove("a1");
        System.out.println(map1);  //{a2=4, 11=1, 12=3}
        //删  clear（清空）
        map2.clear();
        System.out.println(map2);  //{}
        //改  put（这时候put就不是增加了，是覆盖原来的值）
        map1.put("a2",999);
        System.out.println(map1);  //{a2=999, 11=1, 12=3}

查、长度、遍历:

Map map1=new HashMap();
        //增  put（添加一个元素）
        map1.put(11,1);
        map1.put(-13,6);
        map1.put("a1",2);
        map1.put(12,3);
        map1.put("a2",4);
        System.out.println(map1);  //{a1=2, a2=4, 11=1, -13=6, 12=3}
        //查  get（查某个元素的value）
        System.out.println(map1.get(11));  //1
        //查  containsKey（判断某个key是否存在，存在返回true）
        System.out.println(map1.containsKey(11));  //true
        //查  containsValue（判断某个value是否存在，存在返回true）
        System.out.println(map1.containsValue(11));  //false
        //查  isEmpty（集合是否为空）
        System.out.println(map1.isEmpty());  //false
        //长度  size（返回entry的长度）
        System.out.println(map1.size());  //5
        //遍历
        //根据key遍历
        Set set = map1.keySet();
        for (Object o:set){
            System.out.println(o);  //a1 a2 11 -13 12
        }
        //根据value遍历
        Collection values = map1.values();
        for (Object o:values){
            System.out.println(o);  //2 4 1 6 3
        }
        //根据entry遍历
        Set set1 = map1.entrySet();
        for (Object o:set1){
            Map.Entry entry= (Map.Entry) o;
            System.out.println(entry.getKey()+"---->"+entry.getValue());
            //a1=>2  a2=>4  11=>1  -13=>6  12=>3
        }
		
		//有泛型的情况呢！
		Map<String,Integer> map=new HashMap<>();
        map.put("a",1);
        map.put("c",3);
        map.put("b",2);

        Set<Map.Entry<String,Integer>> entrySet=map.entrySet();
        Iterator<Map.Entry<String,Integer>> iterator=entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry<String,Integer> entry=iterator.next();
            String key=entry.getKey();
            Integer value=entry.getValue();
            System.out.println(key+"---->"+value);
            //a---->1  b---->2  c---->3
        }

LinkedHashMap的底层原理（了解）：
LinkedHashMap底层使用的结构和HashMap相同，因为LinkedHashMap继承于HashMap。区别在于：LinkedHashMap内部提供了Entry替换了HashMap中的Node。多了一对指向前后的Entry，所有能够遍历的我们put进去的顺序

java的map放入四万个键值对会有性能要求嘛 map可以放多少数据_数组