1.集合框架

1.1.简述

集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。整个集合框架就围绕一组标准接口而设计。Java 集合框架主要包括两种类型的容器，一种是集合（Collection）：存储一个元素集合，另一种是图（Map）：存储键/值对（key-value）映射，Collection和Map是Java集合框架的根接口。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。所以Java集合大致可以分为Set、List、Queue和Map四种体系，其中Set代表无序、不可重复的集合，List代表有序、重复的集合，而Map则代表具有映射关系的集合，Java 5 又增加了Queue体系集合，代表一种队列集合实现。Java集合就像一种容器，可以把多个对象（实际上是对象的引用，但习惯上都称对象）“丢进”该容器中。从Java 5 增加了泛型以后，Java集合可以记住容器中对象的数据类型，使得编码更加简洁、健壮。

1.1.1.集合框架体系图

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：
接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
类：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

1.1.2.集合架构图

1.1.3.Collection继承关系

说明：虚线代表接口，实线代表类。

1.1.4.Map继承关系

说明：虚线代表接口，实线代表类。

1.2.数组合集合的区别

数组长度在初始化时指定，意味着只能保存定长的数据。而集合可以保存数量不确定的数据。同时可以保存具有映射关系的数据（即关联数组，键值对 key-value）。数组元素即可以是基本类型的值，也可以是对象。集合里只能保存对象（实际上只是保存对象的引用变量），基本数据类型的变量要转换成对应的包装类才能放入集合类中。

2.Collection

2.1.简述

Collection接口是Set、Queue、List的父接口。Collection接口中定义了多种方法可供其子类进行实现，以实现数据操作。

2.2.方法

2.3.使用Iterator遍历集合元素

Iterator接口也是java集合框架的成员，但是与collection系列、map系列不一样，collection系列和map系列主要是用来盛装其他对象，而iterator接口主要用于遍历collection集合中的元素，所以iterator又称为迭代器。

List<String> list =Arrays.asList("java","js","vue");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
    //集合元素的值传给了迭代变量，仅仅传递了对象引用。保存的仅仅是指向对象内存空间的地址
  String next = iterator.next();
  next ="测试";
  System.out.println(next);
}
System.out.println(list);
//运行结果
测试
测试
测试
[java,js,vue]

当使用Iterator对集合元素进行迭代时，Iterator并不是把集合元素本身传给了迭代变量，而是把集合元素的值传给了迭代变量（就如同参数传递是值传递，基本数据类型传递的是值，引用类型传递的仅仅是对象的引用变量），所以修改迭代变量的值对集合元素本身没有任何影响。

2.4.使用Lambda表达式遍历集合

iterable接口是collection接口的父接口，iterable接口的forEach(Consumer action)方法所需的参数类型是一个函数式接口，当程序使用iterable的forEach遍历集合元素时，程序会依次将集合元素传给Consumer的accept(T t)抽象方法。

List<String> list =Arrays.asList("java","js","vue");
list.forEach(obj -> System.out.println("集合元素："+obj));
//运行结果
集合元素：java
集合元素：js
集合元素：vue

2.5.使用Lambda表达式遍历Iterator

Iterator接口的forEachRemaining(Consumer action)方法所需的参数类型是一个函数式接口，传给该方法的参数是一个Lambda表达式，当程序使用Iterator的forEachRemaining遍历集合元素时，程序会依次将集合元素传给Consumer的accept(T t)抽象方法。

List<String> list =Arrays.asList("java","js","vue");
Iterator<String> iterator = list.iterator();
iterator.forEachRemaining(obj -> System.out.println("集合元素"+obj));
//运行结果
集合元素：java
集合元素：js
集合元素：vue

2.6.使用foreach循环遍历集合元素

List<String> list =Arrays.asList("java","js","vue");
for(String obj : list){
    System.out.println("集合元素"+obj)
}
//运行结果
集合元素：java
集合元素：js
集合元素：vue

3.Set

3.1.简述

Set集合与Collection集合基本相同，没有提供任何额外的方法。实际上Set就是Collection，只是行为略有不同（Set不允许包含重复元素）。Set集合不允许包含相同的元素，如果试图把两个相同的元素加入同一个Set集合中，则添加操作失败，add()方法返回false，且新元素不会被加入，并且最多一个空元素。

HashSet：底层数据结构是哈希表。(无序,唯一)
LinkedHashSet：底层数据结构是链表和哈希表。(FIFO插入有序，唯一)
TreeSet：底层数据结构是红黑树。(唯一，有序)。

3.2.方法

3.3.HashSet

3.3.1.简述

HashSet的实质是一个HashMap，HashSet的所有集合元素，构成了HashMap的key，其value为一个静态Object对象。因此HashSet的所有性质，HashMap的key所构成的集合都具备。HashSet是Set接口的典型实现，实现了Set接口中的所有方法，并没有添加额外的方法，大多数时候使用Set集合时就是使用这个实现类。HashSet按Hash算法来存储集合中的元素。因此具有很好的存取和查找性能。当想HashSet集合存入一个元素时，HashSet会调用hashCode()方法来获取元素对象的hashCode值，然后决定该对象在hashSet中的存储位置，如果有两个元素通过equals()方法比较相等，但是它们的hashCode值不一样，HashSet就会把它们存储在不同的位置。HashSet判断两个元素相等的标准：两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法返回值也相等。

3.3.2.特点

（1）不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。
（2）HashSet不是同步的，如果多个线程同时访问一个HashSet，则必须通过代码来保证其同步。
（3）集合元素值可以是null。
除此之外，HashSet判断两个元素是否相等的标准也是其一大特点。HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法返回值也相等。

3.3.2.1.equals方法

equals() 的作用是用来判断两个对象是否相等。
equals() 定义在JDK的Object.java中。通过判断两个对象的地址是否相等(即，是否是同一个对象)来区分它们是否相等。源码如下：

public boolean equals(Object obj) {
    return (this == obj);
}

3.3.2.2.hashCode方法

hashCode() 的作用是获取哈希码，也称为散列码，它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。
hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。虽然，每个Java类都包含hashCode() 函数。但是，仅仅当创建某个类的散列表时，该类的hashCode() 才有用，其它情况下类的hashCode() 没有作用。
在散列表中，在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。
hashCode()也分两种情况。一种是Object类中默认的方法，另一种是在子类中重写的方法。
（1）没有覆盖hashCode()方法
当它的通过hashCode()比较两个对象时，实际上是比较两个对象是不是同一个对象。这时，等价于通过“==”去比较这两个对象，即两个对象的内存地址是否相同。
（2）覆盖类的hashCode()方法
覆盖类的hashCode()方法来让hashCode()通过其它方式比较两个对象是否相等。通常的做法是：若两个对象的内容相等，则hashCode()方法返回true，否则，返回fasle。

3.3.2.3.散列

散列使用一个散列函数，将一个键映射到一个索引上。映射表(map)又称字典(dictionary)、散列表(hash table)或者关联数组(associate array)，是一种使用散列实现的数据结构，用来存取条目的容器对象。
Java合集框架定义了java.util.Map接口来对映射表建模，三个具体实现类为java.util.HashMap(散列实现)、java.util.LinkedHashMap(使用LinkedList)、java.util.TreeMap(使用红黑树)。
存储了值的数组称为散列表(hash table)，将键映射到散列表中的索引上的函数称为散列函数(hash function)。散列(hashing)是一种无需进行搜素，即可通过从键得到的索引来获取值的技术。

3.3.3.LinkedHashSet类

LinkedHashSet是HashSet对的子类，也是根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序，使得元素是以插入的顺序来保存的。当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。但是由于要维护元素的插入顺序，在性能上略低与HashSet，但在迭代访问Set里的全部元素时有很好的性能。LinkedHashSet依然不允许元素重复，判断重复标准与HashSet一致。

3.4.TreeSet

3.4.1.简述

TreeSet是SortedSet接口的实现类，正如SortedSet名字所暗示的，TreeSet可以确保集合元素处于排序状态。对于TreeSet集合而言，判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj)方法比较是否返回0，如果通过compareTo(Object obj)方法比较返回0，TreeSet则会认为它们相等，不予添加入集合内，否则就认为它们不相等，添加到集合内。如果向TreeSet中添加了一个可变对象后，并且后面程序修改了该可变对象的实例变量，这将导致它与其他对象的大小顺序发生了改变，但TreeSet不会再次调整它们。
TreeSet是根据红黑树结构找到集合元素的存储位置。

3.4.2.方法

3.4.3.排序方式

TreeSet并不是通过元素的插入顺序进行排序的，而是通过集合中元素属性进行排序方式来实现的。TreeSet支持两种排序方法：自然排序和定制排序。在默认情况下，TreeSet采用自然排序。

3.4.3.1.自然排序

TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序排列，这种方式就是自然排序。

o1.compareTo(o2)
如果该方法返回=0，则表明两个对象相等；
如果该方法返回>0，则表明o1大于o2；
如果该方法返回<0，则表明o1小于o2。

Java的一些常用类已经实现了Comparable接口，并提供了比较大小的标准。例如，String按字符串的UNICODE值进行比较，Integer等所有数值类型对应的包装类按它们的数值大小进行比较。除了这些已经实现Comparable接口类之外，如果试图把一个对象添加到TreeSet时，则该对象的类必须实现Comparable接口，否则就会出现异常。TreeSet中只能添加同一种类型的对象，否则无法比较，会出现异常。

3.4.3.2.定制排序

在创建TreeSet对象是，提供Comparator对象与TreeSet集合关联，由Comparator对象负责元素的排序逻辑，从而实现自定义排序。

int compare(T o1,T o2)//用于比较o1和o2的大小
如果该方法返回=0，则表明两个对象相等；
如果该方法返回>0，则表明o1大于o1；
如果该方法返回<0，则表明o1小于o1。

举例说明：

User u1 = new User();
u1.setAge(20);
User p2 =new User();
u2.setAge(30);
Comparator<User> comparator = new Comparator<User>() {
  @Override
  public int compare(User o1, User o2) {
    //年龄越小的排在越后面
    if(o1.getAge() < o2.getAge()){
           return 1;
    }else if(o1.getAge() > o2.getAge()){
        return -1;
    }else{
        return 0;
    }
  }
};
TreeSet<User> set = new TreeSet<User>(comparator);
set.add(p1);
set.add(p2);
System.out.println(set);

3.5.EnumSet

3.5.1.简述

EnumSet是一个专为枚举类设计的集合类，EnumSet中的所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显示或隐式地指定。EnumSet的集合元素也是有序的，EnumSet以枚举值在EnumSet类内的定义顺序来决定集合元素的顺序。（比较少用）

public enum Seasons {
    AUTMN,
    WINTER,
    SPRING,
    SUMMER
}
public static void main(String[] args) {  
  EnumSet<Seasons> coldSeasons = EnumSet.of(Seasons.AUTMN, Seasons.WINTER);  
  for (Seasons seasons : coldSeasons) {  
      System.out.println("SEASON:"+seasons.name());  
  }  
} 
//运行结果
SEASON:AUTUMN 
SEASON:WINTER

3.5.2.特点

（1）EnumSet集合不允许加入null元素。EnumSet中的所有元素都必须是指定枚举类型的枚举值。
（2）EnumSet类没有暴露任何构造器来创建该类的实例，程序应该通过它提供的类方法来创建EnumSet对象。

3.5.3.方法

EnumSet没有其他额外增加的方法，只是增加了一些创建EnumSet对象的方法。

3.6.Set集合使用

3.6.1.排序

3.6.1.1.传统排序

Set<String> set = new HashSet<>();
Set<String> sortSet = new TreeSet<String>(new Comparator<String>{
 @Override
 public int compare(String o1,String o2){
  return o1.compareTo(o2);//正序排序 
 }
});
 sortSet.addAll(set);

3.6.1.2.lambda表达式

Set<String> sortSet =  new TreeSet<>(((o1,o2) -> { return o1.compareTo(o2);//正序排序 }))
sortSet.addAll(set);

3.6.1.3.Comparator

在jdk1.8以后，Comparator有正序排序（Comparator.naturalOrder()）和反序排序（Comparator.reverseOrder()）。

TreeSet<String> sortSet = new TreeSet<>(Comparator.naturalOrder());
sortSet.addAll(set);

3.6.1.4.Stream

使用Stream还可以转还成Set或者List，转换成Set需要创建TreeSet，而List可以直接转换，而且List是有序。

List list = new HashSet<String>().stream().sorted(Comparator.naturalOrder()).collect(Collectors.toList());
Set<String> tmp = set.stream().sorted(Comparator.naturalOrder()).collect(Collectors.toSet());
TreeSet<String> sortSet = new TreeSet<>();
sortSet.addAll(tmp);

4.List

4.1.简述

List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素 。List集合默认按元素的添加顺序设置元素的索引，例如第一个添加的元素索引为0，第二个添加的元素索引为1，……，第N个添加的元素索引为N。
List作为Collection接口的子接口，可以使用Collection接口里的全部方法，而且由于List是有序集合，因此List集合里增加了一些根据索引来操作集合元素的方法。注意的是List判断两个对象相等只要通过equals()方法比较返回true。

ArrayList
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高
Vector
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低
LinkedList
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高

4.2.方法

4.3.ArrayList

4.3.1简述

ArrayList作为List类的典型实现，完全支持之前介绍的List接口的全部功能。ArrayList类基于数组实现的List类，所以ArrayList类封装了一个动态的、允许再分配的Object[]数组，因为ArrayList用法类似于数组，且其容量可按需要动态调整，亦被称为动态数组。ArrayList对象使用initalCapacity参数来设置该数组的长度，当向ArrayList中添加元素超过了该数组的长度时，它们的initalCapacity会自动增加。

4.3.2.方法

4.3.3.使用迭代器遍历集合

List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("world");
list.add("!");
Iterator<String> iterator =  list.iterator();
while(iterator.hasNext()){
  String next = iterator.next();
  System.out.println(next);
}
//运行结果
Hello
world
!

4.3.4.通过索引值去遍历

遍历ArrayList时，使用随机访问(即，通过索引序号访问)效率最高，而使用迭代器的效率最低。

for(int i=0;i<list.size();i++){
    System.out.println(list.get(i));
}
//运行结果
Hello
world
!

4.3.5.for循环遍历

for(String obj : list){
    System.out.println(obj);
}
//运行结果
Hello
world
!

4.4.Vector

和ArrayList用法一致，Vector是一个比较老的类，在JDK 1.0即已出现，不推荐使用。虽然Vector是线程安全的，但是在线程安全方面也不推荐使用。推荐方案如下：

List<String> synList = Collections.synchronizedList(lst);

4.5.LinkedList

4.5.1.简述

LinkedList类是List接口的实现类——这意味着它是一个List集合，可以根据索引来随机访问集合中的元素。除此之外，LinkedList还实现了Deque接口，可以被当作成双端队列来使用，因此既可以被当成“栈”来使用，也可以当成队列来使用。LinkedList的实现机制与ArrayList完全不同。ArrayList内部是以数组的形式来保存集合中的元素的，因此随机访问集合元素时有较好的性能，LinkedList底层通过链表来实现，随着元素的增加不断向链表的后端增加节点。LinkedList是一个双向链表，每一个节点都拥有指向前后节点的引用。相比于ArrayList来说，LinkedList的随机访问效率更低，但在插入、删除元素时性能比较出色。LinkedList本质上来讲就是调用默认构造函数，创建一个链表。由于维护了一个表头表尾为Node对象的变量。可以进行后续的添加元素到链表中的操作，以及其他删除，插入等操作。也因此实现了双向队列的功能，即可向表头加入元素，也可以向表尾加入元素。

4.5.2.方法

4.5.3.通过迭代器遍历

List<String> linkedList = new LinkedList<String>();
linkedList.add("my");
linkedList.add("name");
linkedList.add("is");
linkedList.add("maxteng");
Iterator<String> iterator =  linkedList.iterator();
while(iterator.hasNext()){
  String next = iterator.next();
  System.out.println(next);
}
//运行结果
my
name
is
maxteng

4.5.4通过快速随机访问遍历

for(int i=0;i<linkedList.size();i++){
    System.out.println(linkedList.get(i));
}
//运行结果
my
name
is
maxteng

4.5.5.通过for循环遍历

for(String obj : linkedList){
    System.out.println(obj);
}
//运行结果
my
name
is
maxteng

4.5.6.通过pollFirst()遍历

while(linkedList.pollFirst() != null) {
    System.out.println(linkedList);
}
//运行结果
[name, is, maxteng]
[is, maxteng]
[maxteng]
[]

4.5.7.通过pollLast()遍历

while(linkedList.pollLast() != null) {
    System.out.println(linkedList);
}
//运行结果
[my, name, is]
[my, name]
[my]
[]

4.5.8通过removeFirst()遍历

try {  
    while(linkedList.removeFirst() != null) {
        System.out.println(linkedList);
    }
} catch (NoSuchElementException e) {  
} 
//运行结果
[name, is, maxteng]
[is, maxteng]
[maxteng]
[]

4.5.9.通过removeLast()遍历

try {  
    while(linkedList.removeLast() != null) {
        System.out.println(linkedList);
    }
} catch (NoSuchElementException e) {  
}  
//运行结果
[my, name, is]
[my, name]
[my]
[]

4.6.使用场景

涉及到“动态数组”、“栈”、“队列”、“链表”等结构应该使用List。
可以根据下面的标准来选择哪个List。
（1）LinkedList：场景需要快速插入、删除元素。
（2）ArrayList：场景需要快速随机访问元素。
（3）非同步类：“单线程环境” 或者 “多线程环境，但List仅仅只会被单个线程操作”。
（4）同步的类：“多线程环境，且List可能同时被多个线程操作”。

4.7.List集合使用

4.7.1.分组

4.7.1.1.Java 8特性

其中commonRemark是实体类GarGarmentMaterial的属性

Map<String,List<GarGarmentMaterial>> map = list.stream().collect(Collectors.groupingBy(GarGarmentMaterial::getCommonRemark));

4.7.1.2.自定义

其中commonRemark是实体类GarGarmentMaterial的属性

public Map<String,List<GarGarmentMaterial>> listGroupBy(List<GarGarmentMaterial> list){
    Map<String,List<Entity>> map = new HashMap<>();
    for(GarGarmentMaterialtmp:list){
        List<GarGarmentMaterial> tmpList = map.get(tmp.getCommonRemark());
        if(null == tmpList){
            tmpList = new ArrayList<>();
            tmpList.add(tmp);
            map.put(tmp.getCommonRemark(),tmpList);
        }else{
            tmpList.add(tmp);
        }
    }
    return map;
}

5.Queue

5.1.简述

Queue用于模拟队列这种数据结构。队列通常是指“先进先出（FIFO）”的容器。队列的头部保存在队列中存放时间最长的元素，尾部保存存放时间最短的元素。新元素插入（offer）到队列的尾部，访问元素（poll）操作会返回队列头部的元素。通常，队列不允许随机访问队列中的元素。

Queue（队列）接口继承自Collection，用来表示内部元素具有先后顺序的集合。除了基本的集合操作外，队列还提供了其他插入、删除和检查操作。

5.2.方法

add和offer都是在尾部添加元素，并且不建议添加null元素，否则会报空指针，但是不同的是 add方法在添加失败（比如说队列已满）时会报一些运行时的错误，而 offer方法即使在添加失败时也不会奔溃，只会返回 false。remove和poll都是删除并返回头部，不同的是当队列为空时remove方法会报 NoSuchElementException 异常，而poll不会奔溃，只会返回 null。element和peek都是获取但不删除，不同的是当队列为空时 element会抛出异常，而peek不会奔溃，只会返回 null。

5.3.PriorityQueue

5.3.1.简述

PriorityQueue保存队列元素的顺序不是按加入队列的顺序，而是按队列元素的大小进行重新排序。因此当调用peek或pool方法取出队列中头部的元素时，并不是取出最先进入队列的元素，而是取出队列中的最小的元素。PriorityQueue本质也是一个动态数组，在这一方面与ArrayList是一致的。

5.3.2.排序

PriorityQueue中的元素默认是自然排序，也就是如果元素是数字，那么默认排序是从小到大，如果元素是字符串则默认排序按字典序排列，当然也可以通过提供的比较器Comparator在队列实例化时指定的排序方式。

//默认排序
PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>();
priorityQueue.add(5);
priorityQueue.add(3);
priorityQueue.add(7);
priorityQueue.add(2);
priorityQueue.add(9);
while (!priorityQueue.isEmpty()){
    System.out.print(priorityQueue.poll() + "=>");
}
//自定义排序由大道小
Comparator<Integer> cmp = new Comparator<Integer>() {
  public int compare(Integer e1, Integer e2) {
    return e2 - e1;
  }
};
while (!priorityQueue.isEmpty()){
    System.out.print(priorityQueue.poll() + "=>");
}
//运行结果
2=>3=>5=>7=>9
9=>7=>5=>3=>2

5.3.3.特性

(1)队列元素不是根据加入时间进行排序，是根据元素大小进行排序。
(2)默认容量为11。
(3)自动扩容。如果容量小于64，两倍增长扩容，否则增长50%。
(4)无边界容器。
(5)不支持加入null元素。
(6)非线程安全。
(7)支持被序列化。
(8)入队出队的时间复杂度O(log(n))。

6.Map

6.1.简述

最常用的集合类型之一。Map是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键对象和一个值对象。其中键（key）对象不允许重复，而值（value）对象可以重复，并且值对象还可以是Map类型的（如:Map<String,Map<String,String>），就像数组中的元素还可以是数组一样。Map 接口主要有两个实现类：HashMap 类和 TreeMap 类。其中HashMap 类按哈希算法来存取键对象，而 TreeMap 类可以对键对象进行排序。Map与List、Set集合的某些特性有重合。

6.2.方法

6.3.遍历

// Map.Entry遍历
Map<String,List<String>> map = new HashMap<>();
for(Map.Entry<String, List<String>> tmp : map.entrySet()){
 String label = tmp.getKey();
 List<String> values = tmp.getValue()
}
//keySet遍历，分别获取key和value
Set<String> keys = map.keySet();
Iterator<String> it = ks.iterator();
while (it.hasNext()) {
  String key = it.next();
  List<String> value = map.get(key);
}
//通过value遍历，不能获取key
Collection<List<String>> list = map.values();
Iterator<List<String>> it = list.iterator();
while (it.hasNext()) {
    List<String> value = it.next();
}

6.4.HashMap

6.4.1.简述

HashMap是我们最常用的Map，实现了Map接口，继承了AbstractMap类，它根据key的HashCode值来存储数据，通过key可以获取它对应的Value，同时它具有很快的访问速度。HashMap最多只允许一条记录的key值为Null（可以理解为key唯一），允许多条记录的Value为Null。HashMap初始化容量为16，扩容每次为2*oldCap。HashMap是散列表实现，其内部是个Node类型的数组。数组中保存的有两种数据结构，第一种是链表，第二种是树形结构（红黑树）。除此之外HashMap不是线程安全的，不支持线程同步。

6.4.2.排序

HashMap的值是没有顺序的，它是按照key的HashCode来实现的。对于这个无序的HashMap可以参照TreeMap的value排序来实现排序。

Map<String, String> map = new HashMap<String, String>();
map.put("id_1", "my");
map.put("id_2", "name");
map.put("id_3", "is");
map.put("id_4", "maxteng");
List<Map.Entry<String,String>> list = new ArrayList<Map.Entry<String,String>>(map.entrySet());
Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
  //升序排序
  public int compare(Entry<String, String> o1,Entry<String, String> o2) {
      return o1.getValue().compareTo(o2.getValue());
  }
});

6.5.TreeMap

6.5.1.简述

能够把它保存的记录根据键（key）排序，默认是按升序排序，也可以指定排序的比较器。由于TreeMap是有序的，所以其除了实现了Map接口，还实现了SortedMap、NavigableMap接口，当用Iterator 遍历TreeMap时，得到是排序好的记录。TreeMap不允许key的值为null，初始化容量为0，TreeMap内部是红黑树的结构，不存在hash冲突的情况，所以不存在扩容的操作，除此之外TreeMap不是线程安全的，所以不支持线程同步。

6.5.2.排序

Comparator可以对集合对象或者数组进行排序的比较器接口，实现该接口的public compare(T o1,To2)方法即可实现排序，该方法主要是根据第一个参数o1小于、等于或者大于o2分别返回负整数、0或者正整数。

Map<String, String> map = new TreeMap<String, String>(
  new Comparator<String>() {
    public int compare(String obj1, String obj2) {
      // 降序排序
      return obj2.compareTo(obj1);
    }
  });
map.put("id_1", "my");
map.put("id_2", "name");
map.put("id_3", "is");
map.put("id_4", "maxteng");

6.6.Hashtable

与HashMap类似，实现了Map接口，继承了AbstractMap类，因为是散列表实现（内部是数组+链表的结构），所以key和value的值均不允许为null，并且它支持线程的同步，内部方法使用关键字synchronized修饰，所以任一时刻只有一个线程能写Hashtable，因此也导致了Hashtale在写入时会比较慢。Hashtable初始化容量为11，扩容每次为2*oldCap+1。

6.7.集合使用

6.7.1.遍历Map

Map<String,List<String>> map = new HashMap<>();
for(Map.Entry<String, List<String>> tmp : map.entrySet()){
 String label = tmp.getKey();
 List<String> values = tmp.getValue()
}

6.7.2.实体类与Map转换

6.7.2.1.实体类转Map

import com.alibaba.fastjson.JSON;
User user = new User();
Map map = JSON.parseObject(JSON.toJSONString(user), Map.class);

6.7.2.2.Map转实体类

User user = JSON.parseObject(JSON.toJSONString(map), User.class);

6.7.3.判断映射是否包含键值

6.7.3.1.判断映射是否包含指定键

containsKey
boolean containsKey(Object key)如果此映射包含指定键的映射关系，则返回 true。更确切地讲，当且仅当此映射包含针对满足 (key==null ? k==null : key.equals(k)) 的键 k 的映射关系时，返回 true。（最多只能有一个这样的映射关系）。

参数：
key - 测试是否存在于此映射中的键
返回：
如果此映射包含指定键的映射关系，则返回 true
抛出：
ClassCastException - 如果该键对于此映射是不合适的类型（可选）
NullPointerException - 如果指定键为 null 并且此映射不允许 null 键（可选）

实例：

 Map map = new HashMap<>();
 map.containsKey("test");

6.7.3.2.判断映射是否包含指定值

containsValue
boolean containsValue(Object value)如果此映射将一个或多个键映射到指定值，则返回 true。更确切地讲，当且仅当此映射至少包含一个对满足 (value==null ? v==null : value.equals(v)) 的值 v 的映射关系时，返回 true。对于大多数 Map 接口的实现而言，此操作需要的时间可能与映射大小呈线性关系。

参数：
value - 测试是否存在于此映射中的值
返回：
如果此映射将一个或多个键映射到指定值，则返回 true
抛出：
ClassCastException - 如果该值对于此映射是不合适的类型（可选）

7.Stream流