目录

Set系列集合

Set系列集合概述

HashSet元素无序的底层原理：哈希表

HashSet元素去重复的底层原理

实现类：LinkedHashSet

实现类：TreeSet

Collection体系的特点、使用场景总结

补充知识：可变参数

补充知识：集合工具类Collections

Collection体系的综合案例

Map集合体系

Map集合的概述

Map集合体系特点

Map集合常用API

Map集合的遍历方式一：键找值

Map集合的遍历方式二：键值对

Map集合的遍历方式三：lambda表达式

Map集合的实现类HashMap

Map集合的实现类LinkHashMap

Map集合的实现类TreeMap

补充知识：集合的嵌套

Set系列集合

Set系列集合概述

Set系列集合特点● 无序：存取顺序不一致● 不重复：可以去除重复● 无索引：没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。
Set集合实现类特点● HashSet:无序、不重复、无索引。● LinkedHashSet:有序、不重复、无索引。● TreeSet:排序、不重复、无索引。
Set集合的功能基本上与Collection的API一致

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;public class Test {public static void main(String[] args) {//看看Set系列集合的特点：HashSet  LinkedHashSet TreeSetSet sets = new HashSet<>();//一行经典的代码  无序不重复，无索引//Set sets = new LinkedHashSet<>();//有序不重复，无索引sets.add("MySQL");sets.add("MySQL");sets.add("Java");sets.add("Java");sets.add("HTML");sets.add("Python");sets.add("HTML");System.out.println(sets);//[Java, MySQL, HTML, Python]}
}

HashSet元素无序的底层原理：哈希表

HashSet底层原理HashSet集合底层采取哈希表存储的数据。哈希表是一种对于增删改查数据性能都较好的结构。
哈希表的组成JDK8之前的，底层使用数组+链表组成JDK8开始后，底层采用数组+链表+红黑树组成。在了解哈希表之前需要先理解哈希值的概念
哈希值：是JDK根据对象的地址，按照某种规则算出来的int类型的数值。
Object类的APIpublic int hashCode():返回对象的哈希值
对象的哈希值特点同一个对象多次调用hashCode()方法返回的哈希值是相同的默认情况下，不同对象的哈希值是不同的。

public class Test {public static void main(String[] args) {//学会获取对象的哈希值，并确认一下//调用Object的API public int hashCode():返回对象的哈希值String name1 = "王强";System.out.println(name1.hashCode());//941327System.out.println(name1.hashCode());//941327String name2 = "季风";System.out.println(name2.hashCode());//764363System.out.println(name2.hashCode());//764363}
}

JDK1.8版本开始HashSet原理解析底层结构：哈希表（数组、链表、红黑树的结合体）当挂在元素下面的数据过多时，查询性能降低，从JDK8开始后，当链表长度超过8的时候，自动转换为红黑树。

哈希表的详细流程1、创建一个默认长度16,默认加载因为0.75的数组，数组名table2、根据元素的哈希值跟数组的长度计算出应存入的位置3、判断当前位置是否为null,如果是null直接存入，如果位置不为null,表示有元素则调用equals方法比较属性值，如果一样，则不存，如果不一样，则存入数组。4、当数组存满到16*0.75=12时，就自动扩容，每次扩容原先的两倍

HashSet元素去重复的底层原理

Set集合去重复
需求：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
要求：学生对象的成员变量值相同，我们就认为是同一个对象分析1、定义学生类，创建HashSet集合对象，创建学生对象2、把学生添加到集合3、在学生类中重写两个方法，hashCode()和equals(),自动生成即可4、遍历集合（增强for）

import java.util.Objects;public class Student {private String name;private int age;private char sex;public Student() {}public Student(String name, int age, char sex) {this.name = name;this.age = age;this.sex = sex;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}/*** 只要两个对象内容一样，结果一定是true** @param o* @return*/@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age && sex == student.sex && Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, age, sex);}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", sex=" + sex +'}';}
}

import java.util.HashSet;
import java.util.Set;/*** 让Set集合把重复内容的对象去掉一个（去重复）*/
public class Test {public static void main(String[] args) {//Set集合去重复原因：先判断哈希值，再判断equalsSet sets = new HashSet<>();Student s1 = new Student("无恙", 23, '男');Student s2 = new Student("有恙", 20, '男');Student s3 = new Student("无恙", 23, '男');//重写hashCode（）和equals（）方法后s1和s2的哈希值一样，去重System.out.println(s1.hashCode());//System.out.println(s2.hashCode());//System.out.println(s3.hashCode());//sets.add(s1);sets.add(s2);sets.add(s3);System.out.println(sets);//[Student{name='无恙', age=23, sex=男}, Student{name='有恙', age=20, sex=男}]}
}

实现类：LinkedHashSet

LinkedHashSet集合概述和特点
有序、不重复、无索引。
这里的有序指的是保证存储和取出的元素顺序一致
原理：底层数据结构是依然哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序。

实现类：TreeSet

TreeSet集合概述和特点● 不重复、无索引、可排序● 可排序：按照元素的大小默认升序（有小到大）排序。● TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好。
注意：TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序。TreeSet集合默认的规则● 对于数值类型：Integer,Double,官方默认按照大小进行升序排序。● 对于字符串类型：默认按照首字符的编号升序排序。● 对于自定义类型如Student对象，TreeSet无法直接排序。
结论：想要使用TreeSet存储自定义类型，需要制定排序规则

import java.util.Set;
import java.util.TreeSet;/*** 观察TreeSet对于有值特性的数据如何排序* 学会对自定义类型的对象进行指定规则排序*/
public class Test {public static void main(String[] args) {Set sets = new TreeSet<>();//不重复 无索引 排序sets.add(34);sets.add(12);sets.add(28);sets.add(7);sets.add(79);System.out.println(sets);//[7, 12, 28, 34, 79]Set sets1 = new TreeSet<>();sets1.add("Java");sets1.add("Java");sets1.add("java");sets1.add("HTML");sets1.add("angela");sets1.add("伍六七");sets1.add("About");sets1.add("UI");System.out.println(sets1);//[About, HTML, Java, UI, angela, java, 伍六七]}
}

自定义排序规则● TreeSet集合存储对象的的时候有2种方式可以设计自定义比较规则
方式一● 让自定义的类（如Apply类）实现Comparable接口重写里面的compareTo方法来定制比较规则。
方式二● TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则。
两种方式中，关于返回值的规则：● 如果认为第一个元素大于第二个元素返回正整数即可。● 如果认为第一个元素小于第二个元素返回负整数即可。● 如果认为第一个元素等于第二个元素返回0即可，此时TreeSet集合只会保留一个元素，认为两者重复。
注意：如果TreeSet集合存储的对象有实现比较规则，集合也自带比较器，默认使用集合自带的比较器排序。

//接口实现类 Comparable<>自定义比较
public class Apple implements Comparable {private String name;private String color;private double price;private int weight;public Apple() {}public Apple(String name, String color, double price, int weight) {this.name = name;this.color = color;this.price = price;this.weight = weight;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}public int getWeight() {return weight;}public void setWeight(int weight) {this.weight = weight;}@Overridepublic String toString() {return "Apple{" +"name='" + name + '\'' +", color='" + color + '\'' +", price=" + price +", weight=" + weight +'}';}/*** 方法一：类自定义比较规则** @param o* @return*/@Overridepublic int compareTo(Apple o) {/*两种方式中，关于返回值的规则：如果认为第一个元素大于第二个元素返回正整数即可。如果认为第一个元素小于第二个元素返回负整数即可。如果认为第一个元素等于第二个元素返回0即可，此时TreeSet集合只会保留一个元素，认为两者重复。*///return this.weight-o.weight;//去重重量重复元素升序排序return this.weight - o.weight >= 0 ? 1 : -1;//保留重复元素升序排序}
}

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;/*** 观察TreeSet对于有值特性的数据如何排序* 学会对自定义类型的对象进行指定规则排序*/
public class Test {public static void main(String[] args) {Set sets = new TreeSet<>();//不重复 无索引 排序sets.add(34);sets.add(12);sets.add(28);sets.add(7);sets.add(79);System.out.println(sets);//[7, 12, 28, 34, 79]Set sets1 = new TreeSet<>();sets1.add("Java");sets1.add("Java");sets1.add("java");sets1.add("HTML");sets1.add("angela");sets1.add("伍六七");sets1.add("About");sets1.add("UI");System.out.println(sets1);//[About, HTML, Java, UI, angela, java, 伍六七]System.out.println("--------------自定义排序规则-------------");//Set apples = new TreeSet<>();//方式二：集合自带比较器对象进行规则比较/*Set apples = new TreeSet<>(new Comparator() {@Overridepublic int compare(Apple o1, Apple o2) {//重量比较//return o1.getWeight() - o2.getWeight();//去重重量重复元素升序排序//return o1.getWeight() - o2.getWeight() >= 0 ? 1 : -1;//保留重复元素升序排序//价格比较 注意：浮点型用Double.compare进行比较return Double.compare(o1.getPrice(),o2.getPrice());}});*/Set apples = new TreeSet<>((o1, o2) -> Double.compare(o1.getPrice(), o2.getPrice()));apples.add(new Apple("红富士", "红色", 9.9, 500));apples.add(new Apple("青苹果", "青色", 19.9, 300));apples.add(new Apple("绿富士", "绿色", 29.9, 400));apples.add(new Apple("黄富士", "黄色", 9.8, 500));System.out.println(apples);}
}

总结
1. TreeSet集合的特点是怎么样的？● 可排序、不重复、无索引● 底层基于红黑树实现排序，增删改查性能较好
2. TreeSet集合自定义排序规则有几种方式● 2种。● 类实现Comparable接口，重写比较规则。● 集合自定义Comparator比较器对象，重写比较规则。

Collection体系的特点、使用场景总结

1.如果希望元素可以重复，又有索引，索引查询要快？● 用ArrayList集合，基于数组的。(用的最多）
2.如果希望元素可以重复，又有索引，增删首尾操作快？● 用LinkedList集合，基于链表的。
3.如果希望增删改查都快，但是元素不重复、无序、无索引。● 用Hashset集合，基于哈希表的。
4.如果希望增删改查都快，但是元素不重复、有序、无索引。● 用LinkedHashSet集合，基于哈希表和双链表。
5.如果要对对象进行排序。● 用TreeSet集合，基于红黑树。后续也可以用List集合实现排序

补充知识：可变参数

假如需要定义一个方法求和，该方法可以灵活的完成如下需求：● 计算1个数据的和。● 计算2个数据的和。● 计算3个数据的和。● 计算n个数据的和，甚至可以支持不接收参数进行调用。可变参数● 可变参数用在形参中可以接收多个数据。● 可变参数的格式：数据类型...参数名称
可变参数的作用● 传输参数非常灵活，方便。可以不传输参数，可以传输1个或者多个，也可以传输一个数组● 可变参数在方法内部本质上就是一个数组。可变参数的注意事项：● 1.一个形参列表中可变参数只能有一个● 2.可变参数必须放在形参列表的最后面

import java.util.Arrays;/*** 可变参数* ● 可变参数用在形参中可以接收多个数据。* ● 可变参数的格式：数据类型...参数名称* 可变参数的注意事项：* ● 1.一个形参列表中可变参数只能有一个* ● 2.可变参数必须放在形参列表的最后面*/
public class Test {public static void main(String[] args) {sum();//可以不传输参数sum(10);//可以只传输一个参数sum(10, 12, 15);//可以传输多个参数sum(new int[]{10, 20, 32, 35});//可以传输一个数组}/*** 注意：一个形参列表中可变参数只能有一个，可变参数必须放在形参列表的最后面** @param nums*/public static void sum(int... nums) {//注意：可变参数在方法内部其实就是一个数组, numsSystem.out.println("元素个数：" + nums.length);System.out.println("元素内容：" + Arrays.toString(nums));}
}

补充知识：集合工具类Collections

Collections集合工具类● java.utils.Collections:是集合工具类● 作用：Collections并不属于集合，是用来操作集合的工具类。

Collections常用的API

Collections排序相关API
使用范围：只能对于List集合的排序。

注意：本方式不可以直接对自定义类型的List集合排序，除非自定义类型实现了比较规则Comparable接口。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;/*** Collections工具类的使用*/
public class Test {public static void main(String[] args) {List names = new ArrayList<>();
//        names.add("楚留香");
//        names.add("胡铁花");
//        names.add("张无忌");
//        names.add("陆小凤");System.out.println("------------给集合对象批量添加元素------------");//1、public static  boolean addAll(Collection c, T... elements)	给集合对象批量添加元素Collections.addAll(names, "楚留香", "胡铁花", "张无忌", "陆小凤");System.out.println(names);//[楚留香, 胡铁花, 张无忌, 陆小凤]System.out.println("------------打乱List集合元素的顺序------------");//2、public static void shuffle(List list)	打乱List集合元素的顺序Collections.shuffle(names);System.out.println(names);System.out.println("------------将集合中的元素按默认规则排序------------");//3、public static  void sort(List list)	将集合中元素按照默认规则排序//注意：本方式不可以直接对自定义类型的List集合排序，除非自定义类型实现了比较规则Comparable接口。List list = new ArrayList<>();Collections.addAll(list, 12, 11, 34, 23, 3);System.out.println(list);//[12, 11, 34, 23, 3]Collections.sort(list);//默认规则排序System.out.println(list);//[3, 11, 12, 23, 34]}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;public class Test {public static void main(String[] args) {List apples = new ArrayList<>();apples.add(new Apple("红富士", "红色", 9.9, 500));apples.add(new Apple("青苹果", "青色", 19.9, 300));apples.add(new Apple("绿富士", "绿色", 29.9, 400));apples.add(new Apple("黄富士", "黄色", 9.8, 500));/*Collections.sort(apples);//方法一：可以排序，因为Apple重写了compareTo方法System.out.println(apples);*///方式二:sore方法自带比较器对象/*Collections.sort(apples, new Comparator() {@Overridepublic int compare(Apple o1, Apple o2) {return Double.compare(o1.getPrice(),o2.getPrice());//价格升序}});*/Collections.sort(apples, (o1, o2) -> Double.compare(o1.getPrice(), o2.getPrice()));System.out.println(apples);}
}

Collection体系的综合案例

需求：
在启动游戏房间的时候，应该提前准备好54张牌，完成洗牌、发牌、牌排序、逻辑
分析：1、当系统启动的同时需要准备好数据的时候，就可以用静态代码块了。2、洗牌就是打乱牌的顺序。3、定义三个玩家、依次发出51张牌4、给玩家的牌进行排序（拓展）5、输出每个玩家的牌数据。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;/*** 1、做牌* 2、洗牌* 3、定义三个玩家* 4、发牌* 5、给牌排序* 6、看牌*/
public class Test {//1、定义一个静态的集合存储54张牌对象public static List allCards = new ArrayList<>();//2、做牌：定义静态代码块初始化牌数据static {//3、定义点数：个数确定，类型确定，使用数组String[] sizes = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};//4、定义花色：个数确定，类型确定，使用数组String[] colors = {"♠", "❤", "♣", "◆"};//5、组合点数和花色int index = 0;//用来标记牌的大小for (String size : sizes) {index++;for (String color : colors) {//6、封装成一个牌对象Card c = new Card(size, color, index);//7、存入集合容器allCards.add(c);}}//8、将大小王加入集合对象Card c1 = new Card("", "🃏", ++index);//小王Card c2 = new Card("", "☠", ++index);//大王Collections.addAll(allCards, c1, c2);System.out.println("新牌：" + allCards);}public static void main(String[] args) {//9、洗牌Collections.shuffle(allCards);//打乱集合元素System.out.println("洗牌后：" + allCards);//10、发牌（定义三个玩家，每个玩家的牌也是一个集合容器）List xiaoming = new ArrayList<>();List xiaohong = new ArrayList<>();List xiaogang = new ArrayList<>();//11、开始发牌（从牌集合中发出51张个三个玩家，剩余三张作为底牌）//allCards = [8♣, 3♣, 4❤, J♠, 7◆, A◆, 9◆...//    i       0     1   2   3   4   5   6...   % 3for (int i = 0; i < allCards.size() - 3; i++) {//先拿到当前牌对象Card c = allCards.get(i);if (i % 3 == 0) {//请小明接牌xiaoming.add(c);} else if (i % 3 == 1) {//请小红接牌xiaohong.add(c);} else if (i % 3 == 2) {//请小刚接牌xiaogang.add(c);}}//12、拿到最后三张底牌（把最后三张牌截取成一个子集合）List lastThreeCards = allCards.subList(allCards.size() - 3, allCards.size());//13、给玩家的牌排序(从大到小）sortCards(xiaoming);sortCards(xiaohong);sortCards(xiaogang);//14、输出玩家的牌System.out.println("小明的牌:" + xiaoming);System.out.println("小红的牌:" + xiaohong);System.out.println("小刚的牌:" + xiaogang);System.out.println("三张底牌:：" + lastThreeCards);}/*** 给牌排序静态方法** @param cards*/private static void sortCards(List cards) {//cards = [5♣, A◆, 5♠, K❤, 6♠, 2◆, A❤, Q◆..../*Collections.sort(cards, new Comparator() {@Overridepublic int compare(Card o1, Card o2) {//o1 = 5♣//o2 = A◆//知道牌的大小，才可以制定规则(用index来标记牌的大小制定比较规则)return o2.getIndex() - o1.getIndex();}});*/Collections.sort(cards, (o1, o2) -> o2.getIndex() - o1.getIndex());}
}

Map集合体系

Map集合的概述

Map集合概述和使用Map集合是一种双列集合，每个元素包含两个数据。Map集合的每个元素的格式：key=value(键值对元素）。Map集合也被称为“键值对集合”
Map集合整体格式：Collection集合的格式：[元素1,元素2,元素3..]Map集合的完整格式：{key1=value1,key2=value2,key3=value3,...)

Map集合的使用场景之一：购物车系统
分析购物车提供的四个商品和购买的数量在后台需要容器存储。每个商品对象都——对应一个购买数量。把商品对象看成是Map集合的建，购买数量看成Map集合的值。
{商品1=2,商品2=3,商品3=2,商品4=3}

总结
Map集合是什么？使用场景是什么样的？Map集合是键值对集合Map集合非常适合做类购物车这样的业务场景

Map集合体系特点

说明使用最多的Map集合是HashMap。重点掌握HashMap,LinkedHashMap,TreeMap。
Map集合体系特点Map集合的特点都是由键决定的。Map集合的键是无序，不重复的，无索引的，值不做要求（可以重复）。Map集合后面重复的键对应的值会覆盖前面重复键的值。Map集合的键值对都可以为null。
Map集合实现类特点HashMap:元素按照键是无序，不重复，无索引，值不做要求。（与Map体系一致）LinkedHashMap：元素按照键是有序、不重复、无索引，值不做要求TreeMap：元素按照键是排序，不重复，无索引，值不做要求

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;/*** 认识Map体系的特点，按照键无序，不重复，无索引。值不做要求*/
public class Test {public static void main(String[] args) {//1、创建一个Map集合对象Map maps = new HashMap<>();//一行经典的代码maps.put("鞋子", 3);maps.put("Java", 2);maps.put("洗发水", 1);maps.put("Java", 5);//覆盖前面重复的数据maps.put(null, null);System.out.println(maps);//{null=null, Java=5, 鞋子=3, 洗发水=1}Map maps1 = new LinkedHashMap<>();maps1.put("鞋子", 3);maps1.put("Java", 2);maps1.put("洗发水", 1);maps1.put("Java", 5);//覆盖前面重复的数据maps1.put(null, null);System.out.println(maps1);//{鞋子=3, Java=5, 洗发水=1, null=null}}
}

Map集合常用API

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

Map API如下： 

import java.util.*;/*** 认识Map体系的特点，按照键无序，不重复，无索引。值不做要求*/
public class Test {public static void main(String[] args) {//1、V put (K key, V value)	添加元素Map maps = new HashMap<>();//无序不重复无索引maps.put("iphone", 100);maps.put("娃娃", 20);maps.put("iphone", 100);//Map集合后面的重复键对应的元素会覆盖前面的元素maps.put("毛巾", 11);maps.put("手表", 3);//{手表=3, 娃娃=20, iphone=100, 毛巾=11}System.out.println(maps);/* //2、清空集合maps.clear();System.out.println(maps);*///3、判断集合是否为空，为空返回true，反之System.out.println(maps.isEmpty());//4、public V get(Object Key)	根据键获取对应值System.out.println(maps.get("手表"));//3//5、根据键删除整个元素（删除键返回键的值）System.out.println(maps.remove("毛巾"));//11//6、判断是否包含某个键，包含返回true，反之System.out.println(maps.containsKey("毛巾"));//falseSystem.out.println(maps.containsKey("手表"));//true//7、判断是否包含某个值System.out.println(maps.containsValue(100));//trueSystem.out.println(maps.containsValue(5));//false//8、获取全部键的集合：public Set keySet()Set keys = maps.keySet();System.out.println(keys);//[手表, 娃娃, iphone]//9、获取全部值的集合：Collection values（）；Collection values = maps.values();System.out.println(values);//[3, 20, 100]//10、集合大小System.out.println(maps.size());//3//11、合并其他Map集合（拓展）Map map1 = new HashMap<>();map1.put("java1", 1);map1.put("java2", 10);Map map2 = new HashMap<>();map2.put("java2", 1);map2.put("java3", 10);map1.putAll(map2);//把集合map2的元素拷贝一份到map2System.out.println(map1);//{java3=10, java2=1, java1=1}System.out.println(map2);//{java3=10, java2=1}}
}

Map集合的遍历方式一：键找值

Map集合的遍历方式一：键找值先获取Map集合的全部键的Set集合。遍历键的Set集合，然后通过键提取对应值。

键找值涉及到的API:

import java.util.*;public class Test {public static void main(String[] args) {Map maps = new HashMap<>();//无序不重复无索引maps.put("iphone", 100);maps.put("娃娃", 20);maps.put("iphone", 100);//Map集合后面的重复键对应的元素会覆盖前面的元素maps.put("毛巾", 11);maps.put("手表", 3);//{手表=3, 娃娃=20, iphone=100, 毛巾=11}System.out.println(maps);//1、键找值//第一步：先拿到集合的全部键Set keys = maps.keySet();//全部键//第二步：遍历每一个键，根据键取值for (String key : keys) {int value = maps.get(key);//根据键找值System.out.println(key + "===>" + value);}}
}

Map集合的遍历方式二：键值对

Map集合的通历方式二：键值对先把Map集合转换成Set集合，Set集合中每个元素都是键值对实体类型了。遍历Set集合，然后提取键以及提取值。

 键值对涉及到的API:

import java.util.*;public class Test {public static void main(String[] args) {Map maps = new HashMap<>();//无序不重复无索引maps.put("iphone", 100);maps.put("娃娃", 20);maps.put("iphone", 100);//Map集合后面的重复键对应的元素会覆盖前面的元素maps.put("毛巾", 11);maps.put("手表", 3);//{手表=3, 娃娃=20, iphone=100, 毛巾=11}System.out.println(maps);/*maps = {手表=3, 娃娃=20, iphone=100, 毛巾=11}↓使用foreach遍历map集合，发现map集合的键值对元素直接是没有类型的，所以不可以直接foreach遍历集合↓可以通过调用Map的方法entrySty把Map集合转换成Set集合形式  maps.entrySet();[(手表=3),(娃娃=20),(iphone=100),(毛巾=11)]↓此时可以使用foreach遍历*///1、把Map集合转换成Set集合Set> entries = maps.entrySet();//2、开始遍历for (Map.Entry entry : entries) {String key = entry.getKey();//键int value = entry.getValue();//值System.out.println(key + "====>" + value);}}
}

Map集合的遍历方式三：lambda表达式

Map集合的遍历方式三：Lambda得益于JDK 8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。

Map结合Lambda遍历的API

import java.util.*;
import java.util.function.BiConsumer;public class Test {public static void main(String[] args) {Map maps = new HashMap<>();//无序不重复无索引maps.put("iphone", 100);maps.put("娃娃", 20);maps.put("iphone", 100);//Map集合后面的重复键对应的元素会覆盖前面的元素maps.put("毛巾", 11);maps.put("手表", 3);//{手表=3, 娃娃=20, iphone=100, 毛巾=11}System.out.println(maps);/*maps.forEach(new BiConsumer() {@Overridepublic void accept(String key, Integer value) {System.out.println(key+"===>"+value);}});*/maps.forEach((key, value) -> {System.out.println(key + "===>" + value);});}
}

Map集合的实现类HashMap

Map集合案例-统计投票人数
需求某个班级80名学生，现在需要组成秋游活动，班长提供了四个景点依次是（A、B、C、D),每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多。
分析将80个学生选择的数据拿到程序中去。定义Map集合用于存储最终统计的结果。遍历80个学生选择的数据，看Map集合中是否存在，不存在存入“数据=1”，存在则其对应值+1,

//统计投票人数import java.util.HashMap;
import java.util.Map;
import java.util.Random;public class Test {public static void main(String[] args) {//1、把80个学生选择的数据拿进来String[] selects = {"A", "B", "C", "D"};StringBuilder sb = new StringBuilder();Random r = new Random();for (int i = 0; i < 80; i++) {sb.append(selects[r.nextInt(selects.length)]);}System.out.println(sb);//2、定义一个Map集合记录最终统计的结果，键是景点，值是统计投票的数据Map infos = new HashMap<>();//3、遍历80个学生选择的数据for (int i = 0; i < sb.length(); i++) {//4、提取当前选择景点字符char ch = sb.charAt(i);//5、判断Map集合中是否存在这个键if (infos.containsKey(ch)) {//让其值加1infos.put(ch, infos.get(ch) + 1);} else {//说明其景点是第一次去infos.put(ch, 1);}}System.out.println(infos);//投票结果}
}

HashMap的特点HashMap是Map里面的一个实现类。特点都是由键决定的：无序、不重复、无索引没有额外需要学习的特有方法，直接使用Map里面的方法就可以了HashMap跟HashSet底层原理是一模一样的，都是哈希表结构，只是HashMap的每个元素包含两个值而已
实际上：Set系列集合的底层就是Map实现的，只是Set集合中的元素只要键数据，不要值数据而已
public HashS（）{map = new HashMap<>();
}

1、HashMap的特点和底层原理由键决定：无序、不重复、无索引。HashMap底层是哈希表结构的。.依赖hashCode方法和equals方法保证键的唯一。如果键要存储的是自定义对象，需要重写hashCode和equals方法。基于哈希表。增删改查的性能都较好。

Map集合的实现类LinkHashMap

LinkedHashMap集合概述和特点由键决定：有序、不重复、无索引。这里的有序指的是保证存储和取出的元素顺序一致原理：底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。

Map集合的实现类TreeMap

TreeMap集合概述和特点
● 由键决定特性：不重复、无索引、可排序
● 可排序：按照键数据的大小默认升序（有小到大）排序。只能对键排序。
● 注意：TreeMap集合是一定要排序的，可以默认排序，也可以将键按照指定的规则进行排序
TreeMap集合自定义排序规则有2种
● 类实现Comparable接口，重写比较规则。
● 集合自定义Comparator比较器对象，童写比较规则。

import java.util.Map;
import java.util.TreeMap;public class Test {public static void main(String[] args) {Map maps1 = new TreeMap<>();maps1.put(13, "王麻子");maps1.put(1, "张三");maps1.put(2, "县长");//{1=张三, 2=县长, 13=王麻子}System.out.println(maps1);//按键特性进行排序//TreeMap集合自带排序，可排序 不重复（只要大小规则一样就认为重复） 无索引Map maps2 = new TreeMap<>();maps2.put(new Apple("红富士", "红色", 9.9, 500), "山东");maps2.put(new Apple("青苹果", "青色", 19.9, 300), "山西");maps2.put(new Apple("绿富士", "绿色", 29.9, 400), "陕西");maps2.put(new Apple("黄富士", "黄色", 9.8, 500), "河南");System.out.println(maps2);}
}

Map集合实现类特点HashMap:元素按照键是无序，不重复，无索引，值不做要求，基于哈希表（与Map体系一致）LinkedHashMap:元素按照键是有序，不重复，无索引，值不做要求，基于哈希表TreeMap:元素只能按照键排序，不重复，无索引的，值不做要求，可以做排序

补充知识：集合的嵌套

Map集合案例-统计投票人数
需求某个班级多名学生，现在需要组成秋游活动，班长提供了四个景点依次是（A、B、C、D),每个学生可以选择多个景点，请统计出最终哪个景点想去的人数最多。
分析将80个学生选择的数据拿到程序中去，需要记住每个学生选择的情况。定义Map集合用于存储最终统计的结果。

import java.util.*;public class Test {public static void main(String[] args) {//1、记录学生的选择情况//使用一个Map集合存储信息Map> data = new HashMap<>();//嵌套集合//2、把学生选择的数据存入集合List selects = new ArrayList<>();Collections.addAll(selects, "A", "C");data.put("小明", selects);List selects1 = new ArrayList<>();Collections.addAll(selects1, "A", "B", "C");data.put("小花", selects1);List selects2 = new ArrayList<>();Collections.addAll(selects2, "A", "B", "C", "D");data.put("小刚", selects2);//{小刚=[A, B, C, D], 小明=[A, C], 小花=[A, B, C]}System.out.println(data);//3、统计每个景点的选择人数Map infos = new HashMap<>();//4、提取所有人选择的景点信息Collection> values = data.values();System.out.println(values);//values = [[A, B, C, D], [A, C], [A, B, C]]for (List value : values) {for (String s : value) {//有没有包含这个景点if (infos.containsKey(s)) {infos.put(s, infos.get(s) + 1);} else {infos.put(s, 1);}}}System.out.println(infos);//{A=3, B=2, C=3, D=1}}
}