Set、可变参数、Collections工具类、Map集合

一，set集合

Collection集合的体系结构：

List集合的见上个笔记，这个主要来学习Set和Map中的类

1，Set集合的特点

Set系列集合的特点：无序 < 添加和取出的顺序不一致> ：不重复，无索引

三个主要的实现类：

HashSet: 无序，不重复，无索引

LinkeHashSet： 有序，不重复，无索引

TreeSet ： 用来排序，不重复，无索引

前面先学了他们父接口，Collection，当时有说到，因为父亲要兼顾子类的特性，所以父亲的方法都是中和与连个类的特性，存在的方法。比如，add 方法，clear方法，remove（ E e），contains，idEmpty，size，toArray。等 很容易发现这些方法都是很中规中矩。但因为Set集合的特点其实Set集合也就这些方法。List比接口中多的也就无非哪些通过索引操作数据的方法。

即Set中常用的方法如下：

方法名	说明
public boolean add(E e)	把给定的对象添加到当前集合中
public void clear()	清空集合中所有的元素
public boolean remove(E e)	把给定的对象在当前集合中删除
public boolean contains(Object obj)	判断当前集合中是否包含给定的对象
public boolean isEmpty()	判断当前集合是否为空
public int size()	返回集合中元素的个数。
public Object[] toArray()	把集合中的元素，存储到数组中

2，HashSet集合的底层原理

首先先了解一个知识，Hash值：

• 就是一个int类型的数值，Java中每个对象都有一个哈希值。
• Java中的所有对象，都可以调用obejct类提供的hashCode方法，返回该对象自己的哈希值

先看Object中hashCode的源码：

@IntrinsicCandidate
public native int hashCode();

native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。也就是说在java源码中看不到，但是我们可以从等下的对象重写的方法中知道这个方法是干什么的

这个算法其实就是根据传入的对象，然后通过内部的一通运算返回一个int值。

对象哈希值的特点<小重点>：

• 同一个对象多次调用hashCode()方法返回的哈希值是相同的。 <因为传入的参数一样，里面的运算一样，所以返回的数据肯定一样呀>
• 不同的对象，它们的哈希值一般不相同，但也有可能会相同(哈希碰撞)。<因为int的取值有限，那么传入参数之后的运算结果就有概率相同。很低，这个也称为哈希碰撞>

// hash碰撞
String s = "通话";
String s4 = "重地";
System.out.println(s.hashCode());   // 1179395
System.out.println(s4.hashCode());  // 1179395

HashSet集合的底层实现原理 ： 基于哈希表实现，哈希表是一种增删改查数据，性能都较好的数据结构

JDk8之前： 哈希表 = 数组+ 链表

jdk8开始： 哈希表 = 数组+ 链表+红黑树

1，jdk8之前HashSet集合底层的原理， 哈希表 = 数组+ 链表

1. 创建一个默认长度为16的数组，默认加载因子为0.75<下面介绍>，数组名为table

2. 使用元素的哈希值对数组的长度的求余计算出应存入的位置。

3. 判断是否为null，如果为null直接存入

4. 如果不为null，表示在这个索引已经有其他的元素了，则调用equals方法比较是否相等，相等，则不存，不相等，则存入数组<当前位置的链表中>

   a、 JDk 8 之前，新的元素存入数组，占老元素位置，老元素往链表上挂，

   b、 JDk8 之后， 新元素直接挂载老元素下面 <又细微的提高了性能，没有了新老元素的来回折腾>

过程如下：（ 兄弟们一定要学会做动图啊）

当添加第一个元素的时候，就会默认创建一个大小为16的数组。这里的两个球是两个对象，当存入的时候java会调用hashCode方法求出当前对象的Hash值，如果当前对象重写了，那么就调用自己的HashCode方法，如果没有就是Object的hashCode方法。这样就得到了当前对象的Hash值。然后用这个hash值对数组的长度求余，就得出了对应的索引。然后将当前元素存入对应的索引位置即可。如果当前位置已经有了，那么就通过equals比较，如果相同，就不添加，如果不相同，如下图，jdk8之前是对象1，占用对象2 的位置，对象2以链表的方式，接在对象1的后面。jdk8之后是直接链接在后面

在说一下加载因子的作用，我们会发现在hash值对数组的长度求余之后得到了一个索引，但是问题是索引就16个，随着对象的增加，数组中的位置也会被占用，就取个极限，当前已经有15个了，那么就还有一个位置，这样很容易的就发生了hash碰撞，但是如果定义的空间太大，又很浪费内存资源，那么有没有一个很好的临界值，当然有，通过研究发现，也就是当前数组的 75%，即加载因子的0.75，即能保证空间的利用率最高，也能尽量的避免哈希碰撞

那么什么时候数组会扩容呢？一种情况是当数组中的大小超过了这个临界值，即 数组的长度 X 加载因子 ，这个时候就会扩容，扩容的规则是两倍的扩容。还有一种情况如下：

我们上面都是忽略了链表，这样好做分析，下面我们就从链表来看，我们会发现即使有了加载因子，也难免会发生hash冲突的问题。上面说到如果，冲突了，就会调用equals方法对两个对象作比较。如果相同则舍弃，如果不同则以链表的方式添加。取一个极端，就是对象中的hash值一直相同，但是通过equals方法比较之后的结果为false，那么就会一直在链表的尾部进行插入对象，如果不规定一个界限，这样子在查询的时候就会很慢，但是我们使用hash表的结构就是为了提高速度。怎么解决呢？java规定，如果这个链表的长度大于8时，就认为这个数组已经满了，很容易产生哈希碰撞。需要进行扩容，然后就会把16的数组扩容为32，如果单个链表的长度还是超过8或数组的长度超过了临界值 32 * 0.75，那么就会继续扩容。扩容到64。 如果某个链表的长度还是超过8，这次就不在扩容了，就会树化，把当前的链表转换为红黑树的数据结构 ，即JDK8开始，当链表长度超过8，且数组长度>=64时，自动将链表转成红黑树

如果我们想看到这种现象，我们可以在循环中new 一个自定义的对象，并且对象中重写了hashCode方法，没有重写equals方法<比较地址>，这个时候就会一直hash冲突，然后判断，不相等，一直扩容，知道树化。可以通过debug的方法查看细节

但是idea默认隐藏了细节，所以需要取消勾选这两个位置，就可以看到啦

上面提到了数据结构中树，为了防止忘记，就对树作一个复习：

最简单的树是二叉树🌲 ：每个位置叫做一个节点

几个概念：

度：每一个节点的子节点数量

树高：树的总层数

根节点：最顶层的节点

如果我们规定，小的元素存在根节点的左边，大的存右边，我们就得到了二叉查找树（二叉排序树）

又有一个问题：如果有这样的一堆递增的数据，我们选用第一个为根节点，这样的数就会很奇怪，就类似于链表,这样的查找效率非常低；即： 当数据已经是排好序的，导致查询的性能与单链表一样，查询速度变慢！

那么我们就需要对其做出一些改正：在满足查找二叉树的大小规则下，让树尽可能矮小，以此提高查数据的性能。 由二叉查找树到二叉平衡数，就需要通过左旋，或者右旋的操作来实现 改变树的结构，很浪费资源。所以又引进了红黑树：

红黑树，就是可以自平衡的二叉树，红黑树是一种增删改查数据性能相对都较好的结构。 所以hashSet底层就是用这种数据结构。

3，LinkedHashSet集合底层的原理

通过最上面的继承图我们可以看到LinkedHashSet是HashSet的子类，我们知道子类一般都是在父类的基础上在某个方面做一个改进。LinkedHashSet也不例外，他是在底层的数据结构中做了一个改变。通过之前我们知道HashSet是无序的，即存入和取出的顺序不一致，而LinkedHashSet是有序的，那么他肯定在存入数据的时候做了一些改变。先从结构入手：

LinkedHashSet: 底层依然是基于哈希表(数组、链表、红黑树)实现的。但是，它的每个元素都额外的多了一个双链表的机制记录它前后元素的位置。

通过双链表也就实现了前后位置存入了取出顺序一致的问题；大致如下

4，TreeSet集合

TreeSet的作用就是给无序的Set集合排序用的。

特点： 特点：不重复、无索引、可排序（默认升序排序 ，按照元素的大小，由小到大排序）

底层是基于红黑树实现的排序。

对于数值类型：Integer , Double，默认按照数值本身的大小进行升序排序。
对于字符串类型：默认按照首字符的编号升序排序。
对于自定义类型如Student对象，TreeSet默认是无法直接排序的。需要自己处理

注意事项：

TreeSet集合存储自定义类型的对象时，必须指定排序规则，支持一下两种方式来指定规则。

方式一：

让自定义类，实现Comparable接口，重写里面的compareTo方法来指定比较规则。

方式二：

通过调用TreeSet集合有参构造器，可以设置Comparator对象（比较器对象，用于指定比较规则）

如果对自定义类不通过上面的两种方法处理，直接使用就会引发 ClassCastException异常

前一个对象和后一个对象比较是升序， 反过来是降序。 如果是实现Comparable接口重写compareTo方法那么前一个对象就是当前对象。

如果这个自定义类中实现了Comparable接口，在创建对象的时候有使用了Comparator这个比较器定义了比较方法，则比较器优先

5，注意事项：集合的并发修改异常

问题：

使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。

由于增强for循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强for循环遍历集合，又在同时删除集合中的数据时，程序也会出现并发修改异常的错误

返回值	方法名	方法说明
boolean	hasNext()	如果迭代具有更多元素，则返回 true 。
E	next()	返回迭代中的下一个元素。
default void	remove()	从底层集合中移除此迭代器返回的最后一个元素（可选操作）。

怎么保证遍历集合同时删除数据时不出bug？

• 使用迭代器遍历集合，但用迭代器自己的删除方法删除数据即可。
• 如果能用for循环遍历时：可以倒着遍历并删除；或者从前往后遍历，但删除元素后做i --操作。

下面对出现异常的原因做一个简单的概述：

hasNext方法是判断下一个还是否有元素，而next有两个作用，1，是返回当前的元素，二是确定当前的位置，也就是一个指针，当返回当前的元素之后这个指针就会往后面挪一下。 下面的代码前面判断后面有元素，但是在获取之前把这个元素给删了，所以在通过next获取时候找不到了，就很尴尬。所以就出现了 ClassCastException 这个异常

另外还有一 种情况，就是获取时候获取了两次，因为在他获取之后会移动指针，如果前一次就是最后一个了，下一次再去获取当然找不到了，所以有出现了这个异常。

		while (iterator.hasNext()) {
            students.remove(new Student("张三",20));
            iterator.next();
            iterator.next();
        }

二，可变参数、Collections工具类

1，可变参数

就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型... 参数名称；

可变参数的特点和好处：

特点： 可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。

好处： 常常用来灵活的接收数据。

可变参数的注意事项：

• 可变参数在方法内部就是一个数组。

• 一个形参列表中可变参数只能有一个

• 可变参数必须放在形参列表的最后面

有这样的一个需求，需要计算1个数据的和。计算2个。。。n个数的和。

public static void main(String[] args) {
    // 一个两个，三个都可以，很香好吧
    System.out.println(getSum(12));
    System.out.println(getSum(12,34));
    System.out.println(getSum(12, 34, 54));
}
public static int getSum(int... args) {
    int sum = 0;
    for (int arg : args) {
        sum += arg;
    }
    return sum;
}

2，Collections

是一个用来操作集合的工具类

常用方法：

方法名称	说明
public static boolean addAll(Collection<? super T> c, T... elements)	给集合批量添加元素
public static void shuffle(List<?> list)	打乱List集合中的元素顺序
public static void sort(List list)	对List集合中的元素进行升序排序
public static void sort(List list，Comparator<? super T> c)	对List集合中元素，按照比较器对象指定的规则进行排序

注意点：Collections只能支持对List集合进行排序

排序方式1：

方法名称	说明
public static void sort(List list)	对List集合中元素按照默认规则排序

注意：本方法可以直接对自定义类型的List集合排序，但自定义类型必须实现了Comparable接口，指定了比较规则才可以。

排序方式2：

方法名称	说明
public static void sort(List list，Comparator<? super T> c)	对List集合中元素，按照比较器对象指定的规则进行排序

三，Map集合

1，概述

• Map集合称为双列集合，格式：{key1=value1 , key2=value2 , key3=value3 , ...}， 一次需要存一对数据做为一个元素.

• Map集合的每个元素“key=value”称为一个键值对 / **键值对对象 / ** 一个Entry对象，Map集合也被叫做“键值对集合”

• Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值

集合体系结构：

Map集合体系的特点：

注意：Map系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的

• HashMap（由键决定特点）: 无序、不重复、无索引； （用的最多）

• LinkedHashMap （由键决定特点）:由键决定的特点：有序、不重复、无索引。

• TreeMap （由键决定特点）:按照大小默认升序排序、不重复、无索引。

2，常用方法

Map是双列集合的祖宗，它的功能是全部双列集合都可以继承过来使用的。

方法名称	说明
public V put(K key,V value)	添加元素
public int size()	获取集合的大小
public void clear()	清空集合
public boolean isEmpty()	判断集合是否为空，为空返回true , 反之
public V get(Object key)	根据键获取对应值
public V remove(Object key)	根据键删除整个元素
public boolean containsKey(Object key)	判断是否包含某个键
public boolean containsValue(Object value)	判断是否包含某个值
public Set keySet()	获取全部键的集合
public Collection values()	获取Map集合的全部值
static <K,V>Map.Entry<K,V> entry(K k, V v)	返回包含给定键和值的不可修改的 Map.Entry

3，遍历方式

不怕千招会就怕一招绝

有这样的一个Map集合：

HashMap<Integer, String> map = new HashMap<>();
//      编号   名称
map.put(1001, "开封四味菜");
map.put(1002, "鼓楼炒凉粉");
map.put(1003, "黄家灌汤包");
map.put(1004, "王新力涮锅");

方式一：键找值

先获取Map集合全部的键，再通过遍历键来找值

需要用到的方法：

方法名称	说明
public Set keySet()	获取所有键的集合
public V get(Object key)	根据键获取其对应的值

遍历代码：

Set<Integer> keySet = map.keySet();
for (Integer integer : keySet) {
    System.out.println("编号:" + integer + "店名:" + map.get(integer));
}

方式二：键值对

把“键值对“看成一个整体进行遍历（难度较大），这个是因为Map中有创建了一个内部接口Entry。因为java的核心是万物皆对象，而这里所有的键值对就可以看作一个是一个对象，每个键值对是对象中的一个元素，这样就很符合java的设计思想了；

通过上面图可以看到右边就是Map内部维护的Entry，而Entry的key，又是一个keySet对象，所以在我们获取的时候就十分的方便啦。通过keySet方式获取，也就是上面的方式一。下面就是用Entry对象来获取。

Map.Entry提供的方法	说明
K getKey()	获取键
V getValue()	获取值

//       方式二 通过EntrySet方法来获取 ,键值对对象
Set<Map.Entry<Integer, String>> entries = map.entrySet();
for (Map.Entry<Integer, String> entry : entries) {
    System.out.println("编号:" + entry.getKey() + "店名:" + entry.getValue());
}

方式三：Lambda表达式

JDK 1.8开始之后的新技术（非常的简单），需要用到Map中的方法

方法名称	说明
default void forEach(BiConsumer<? super K, ? super V> action)	结合lambda遍历Map集合

参数中的第一个参数就是键 key，第二个就是 值 value ， 方法体中直接用就可以

//   方式三,通过lambda表达式
map.forEach((key, value) -> System.out.println("编号:" + key + "店名:" + value));

学了遍历之后完成一个需求： 键盘录入一个字符串, 请统计字符串中每个字符出现的次数?

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        HashMap<String, Integer> map = new HashMap<>();

        System.out.println("请输入一个字符串:");
        String str = sc.next();

        for (int i = 0; i < str.length(); i++) {
            String key = str.charAt(i) + "";
            if (map.get(key) == null) {
//                这个时候说明没有这个元素，那么就添加
                map.put(key, 1);
            } else {
                Integer value = map.get(key);
                map.put(key, ++value);
            }
        }

        map.forEach((key, value) -> System.out.println(key + "---" + value));
}

4，HashMap

HashMap集合的底层原理。上面详细的介绍了HashSet的底层原理，实际上HashMap底层原理和HashSet是一样的。为什么这么说呢？因为我们往HashSet集合中添加元素时，实际上是把元素作为键添加到了HashMap集合中。

HashSet底层就是HashMap，我们可以看源码验证这一点，如下图所示，我们可以看到，创建HashSet集合时，底层帮你创建了HashMap集合；往HashSet集合中添加添加元素时，底层却是调用了Map集合的put方法把元素作为了键来存储。所以实际上根本没有什么HashSet集合，把HashMap的集合的值忽略不看就是HashSet集合。

所以HashMap和HashSet是一样的，底层是哈希表结构。

HashMap底层数据结构: 哈希表结构
	JDK8之前的哈希表 = 数组+链表
	JDK8之后的哈希表 = 数组+链表+红黑树
	哈希表是一种增删改查数据，性能相对都较好的数据结构
	
往HashMap集合中键值对数据时，底层步骤如下
	第1步：当你第一次往HashMap集合中存储键值对时，底层会创建一个长度为16的数组
	第2步：把键然后将键和值封装成一个对象，叫做Entry对象
	第3步：再根据Entry对象的键计算hashCode值（和值无关）
	第4步：利用hashCode值和数组的长度做一个类似求余数的算法，会得到一个索引位置
	第5步：判断这个索引的位置是否为null，如果为null,就直接将这个Entry对象存储到这个索引位置
		   如果不为null，则还需要进行第6步的判断
	第6步：继续调用equals方法判断两个对象键是否相同
		  如果equals返回false，则以链表的形式往下挂
		  如果equals方法true,则认为键重复，此时新的键值对会替换旧的键值对。
	
HashMap底层需要注意这几点：
	1.底层数组默认长度为16，如果数组中有超过12个位置已经存储了元素，则会对数组进行扩容2倍
	  数组扩容的加载因子是0.75，意思是：16 * 0.75 = 12 	
   	
    2.数组的同一个索引位置有多个元素、并且在8个元素以内(包括8)，则以链表的形式存储
    	JDK7版本：链表采用头插法（新元素往链表的头部添加）
    	JDK8版本：链表采用尾插法（新元素我那个链表的尾部添加）
    	
    3.数组的同一个索引位置有多个元素、当超过了8个，并且数组的长度为64时，则以红黑树形式存储

从HashMap底层存储键值对的过程中我们发现：决定键是否重复依赖与两个方法，一个是hashCode方法、一个是equals方法。有两个键计算得到的hashCode值相同，并且两个键使用equals比较为true，就认为键重复。

所以，往Map集合中存储自定义对象作为键，为了保证键的唯一性，我们应该重写hashCode方法和equals方法。缺一不可

小案例：

往HashMap集合中存储Student对象作为键，学生的家庭住址当做值。要求，当学生对象的姓名和年龄相同时就认为键重复。

public class Student implements Comparable<Student> {
    private String name;
    private int age;
    private double height;

    @Override
    public boolean equals(Object o) {

        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;

        return Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        temp = Double.doubleToLongBits(height);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        return result;
    }
    //  setter和getter toString 省略。。。
}

public class Test1HashMap {
    public static void main(String[] args) {
        Map<Student, String> map = new HashMap<>();
        map.put(new Student("蜘蛛精", 25, 168.5), "盘丝洞");
        map.put(new Student("蜘蛛精", 25, 168.5), "水帘洞");
        map.put(new Student("至尊宝", 23, 163.5), "水帘洞");
        map.put(new Student("牛魔王", 28, 183.5), "牛头山");
        System.out.println(map);
    }
}

5，LinkedHashMap

LinkedHashMap集合的特点也是由键决定的：有序的、不重复、无索引。

    public static void main(String[] args) {
        //  按照键 有序，不重复，无索引。
        LinkedHashMap<String, Integer> map = new LinkedHashMap<>(); 
        map.put("手表", 100);
        map.put("手表", 220);
        map.put("手机", 2);
        map.put("Java", 2);
        map.put(null, null);
        System.out.println(map);
    }

结果：

{手表=220, 手机=2, Java=2, null=null}

LinkedHashMap的底层原理，和LinkedHashSet底层原理是一样的。底层多个一个双向链表来维护键的存储顺序。

6，TreeMap

TreeMap集合的特点也是由键决定的，默认按照键的升序排列，键不重复，也是无索引的。

• TreeMap集合的底层原理和TreeSet也是一样的，底层都是红黑树实现的。所以可以对键进行排序。

比如往TreeMap集合中存储Student对象作为键，排序方法有两种。直接看代码吧

排序方式1： 写一个Student类，让Student类实现Comparable接口

//第一步：先让Student类，实现Comparable接口
public class Student implements Comparable<Student>{
    private String name;
    private int age;
    private double height;
	//无参数构造方法
    public Student(){}
    //全参数构造方法
    public Student(String name, int age, double height){
        this.name=name;
        this.age=age;
        this.height=height;
    }
    //...get、set、toString()方法自己补上..
    
    //按照年龄进行比较，只需要在方法中让this.age和o.age相减就可以。
    /*
    原理：
    在往TreeSet集合中添加元素时，add方法底层会调用compareTo方法，根据该方法的
    结果是正数、负数、还是零，决定元素放在后面、前面还是不存 0表示不存<java认为为0是二者相等>。
    */
    @Override
    public int compareTo(Student o) {
        //this：表示将要添加进去的Student对象
        //o: 表示集合中已有的Student对象
        return this.age-o.age;
    }
}

排序方式2： 在创建TreeMap集合时，直接传递Comparator比较器对象。

public class Test3TreeMap {
    public static void main(String[] args) {
        Map<Student, String> map = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getHeight(), o2.getHeight());
            }
        });
 // 上面是使用匿名内部类，下面使用lambda表达式，这里是认为身高相同就是重复，然后按照升序排列
//Map<Student, String> map = new TreeMap<>(( o1,  o2) ->   Double.compare(o2.getHeight(), o1.getHeight()));
        map.put(new Student("蜘蛛精", 25, 168.5), "盘丝洞");
        map.put(new Student("蜘蛛精", 25, 168.5), "水帘洞");
        map.put(new Student("至尊宝", 23, 163.5), "水帘洞");
        map.put(new Student("牛魔王", 28, 183.5), "牛头山");
        System.out.println(map);
    }
}

7，循环嵌套

在实际开发中可能还会存在一种特殊的用法。就是把一个集合当做元素，存储到另一个集合中去，我们把这种用法称之为集合嵌套。

有这样一个需求:

要求在程序中记住如下省份和其对应的城市信息，记录成功后，要求可以查询出湖北省的城市信息

需求结果如下： 湖南:[武汉, 孝感, 十堰, 宜昌, 鄂州, 湘潭]

分析: 我们可以用一个Map集合的键表示省份名称，而值表示省份有哪些城市 而又因为一个身份有多个城市，同一个省份的多个城市可以再用一个List集合来存储。
所以Map集合的键是String类型，而值是List集合类型
HashMap<String, List> map = new HashMap<>();

    public static void main(String[] args) {
        Map<String, ArrayList<String>> map = new HashMap<>();
//        添加数据
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1, "郑州", "开封", "洛阳", "平顶山", "驻马店", "信阳");
//        添加到map中
        map.put("河南", list1);

        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2, "石家庄", "廊坊", "唐山", "邢台", "保定", "张家口");
        map.put("河北", list2);

        ArrayList<String> list3 = new ArrayList<>();
        Collections.addAll(list3, "武汉", "孝感", "十堰", "宜昌", "鄂州", "湘潭");
        map.put("湖南", list3);
//        打印
        map.forEach((key, value) -> System.out.println(key + ":" + value));

    }

河南:[郑州, 开封, 洛阳, 平顶山, 驻马店, 信阳]
河北:[石家庄, 廊坊, 唐山, 邢台, 保定, 张家口]
湖南:[武汉, 孝感, 十堰, 宜昌, 鄂州, 湘潭]

内容涉及较多的底层，如果大家发现有错误，或者是用词不妥的地方还望指教😄

加油呀🍡🍡🍡