【Java从入门到大牛】集合进阶下篇

我不是女神ヾ 2024-04-26 02:50 83阅读 0赞

> ? 本文由 [程序喵正在路上][Link 1] 原创，CSDN首发！  
> ? 系列专栏：[Java从入门到大牛][Java]  
> ? 首发时间：2023年8月2日  
> ? 欢迎关注?点赞?收藏?留言?  
> ? 一以贯之的努力 不得懈怠的人生

#### 目录 ####

*  Collection的其他相关知识
 *   *  可变参数
     *  Collections
     *  综合案例
 *  Map集合
 *   *  概述
     *  常用方法
     *  遍历方式
     *  HashMap
     *  LinkedHashMap
     *  TreeMap
     *  集合的嵌套
 *  JDK8新特性：Stream流
 *   *  认识Stream
     *  Stream的常用方法

## Collection的其他相关知识 ##

### 可变参数 ###

**什么是可变参数**

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

**可变参数的特点和好处**

*  特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它
 *  好处：常常用来灵活地接收数据

**可变参数的注意事项**

*  可变参数在方法内部就是一个数组
 *  一个形参列表可变参数只能有一个
 *  可变参数必须放在形参列表的最后面

**具体应用**

import java.util.Arrays;
    
    /**
     * 目标：认识可变参数，掌握其作用
     */
    public class ParamTest {
        
        public static void main(String[] args) {
        
            // 特点：
            test(); // 不传数据
            test(10); // 传输一个数据给它
            test(10, 20, 30); // 传输多个数据给它
            test(new int[]{
        10, 20, 30, 40}); // 传输一个数组给可变参数
        }
    
        // 注意事项1：一个形参列表中，只能有一个可变参数。
        // 注意事项2：可变参数必须放在形参列表的最后面
        public static void test(int...nums){
        
            // 可变参数在方法内部，本质就是一个数组。
            System.out.println(nums.length);
            System.out.println(Arrays.toString(nums));
            System.out.println("-----------------------------------------");
        }
    }

![在这里插入图片描述][a1553c59aa244bc2b33bd75705ca9e81.png]

### Collections ###

**什么是 Collections ？**

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

**Collections提供的常用静态方法**  
![在这里插入图片描述][200905f1d06e4ce3aebafc5ecadbb797.png]

**Collections只能支持对List集合进行排序**

*  排序方式1：
    
        public static <T> void sort(List<T> list)	// 对List集合中元素按照默认规则排序
    
    注意：本方法可以直接对自定义类型的 List 集合排序，但自定义类型必须实现了 Comparable 接口，指定了比较规则才可以
 *  排序方式2：
    
        public static <T> void sort(List<T> list, Comparator<? super T> c)	// 对List集合中元素，按照比较器对象指定的规则进行排序

**具体应用**

**学生类**

public class Student implements Comparable<Student>{
        
        private String name;
        private int age;
        private double height;
    
        @Override
        public int compareTo(Student o) {
        
            // 按照年龄升序排序
            return this.age - o.age;
        }
    
        public Student() {
        
        }
    
        public Student(String name, int age, double height) {
        
            this.name = name;
            this.age = age;
            this.height = height;
        }
    
        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 double getHeight() {
        
            return height;
        }
    
        public void setHeight(double height) {
        
            this.height = height;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", height=" + height +
                    '}';
        }
    }

**测试类**

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    /**
     * 目标：掌握Collections集合工具类的使用
     */
    public class CollectionsTest1 {
        
        public static void main(String[] args) {
        
            // 1、public static <T> boolean addAll(Collection<? super T> c, T...elements)：为集合批量添加数据
            List<String> names = new ArrayList<>();
            Collections.addAll(names, "张三", "王五", "李四", "张麻子");
            System.out.println(names);
    
            // 2、public static void shuffle(List<?> list)：打乱List集合中的元素顺序。
            Collections.shuffle(names);
            System.out.println(names);
    
            // 3、 public static <T> void sort(List<T> list)：对List集合中的元素进行升序排序。
            List<Integer> list = new ArrayList<>();
            list.add(3);
            list.add(5);
            list.add(2);
            Collections.sort(list);
            System.out.println(list);
    
            List<Student> students = new ArrayList<>();
            students.add(new Student("蜘蛛精",23, 169.7));
            students.add(new Student("紫霞",22, 169.8));
            students.add(new Student("紫霞",22, 169.8));
            students.add(new Student("至尊宝",26, 165.5));
    //        Collections.sort(students);
    //        System.out.println(students);
    
            // 4、public static <T> void sort(List<T> list， Comparator<? super T> c): 对List集合中元素，按照比较器对象指定的规则进行排序
            Collections.sort(students, new Comparator<Student>() {
        
                @Override
                public int compare(Student o1, Student o2) {
        
                    return Double.compare(o1.getHeight(), o2.getHeight());
                }
            });
            System.out.println(students);
        }
    }

![在这里插入图片描述][52813b2799a540f19a2a3b4bea85ef03.png]

### 综合案例 ###

**案例：斗地主游戏**

**分析业务需求**

*  总共有 54 张牌
 *  点数: “3”,“4”,“5”,“6”,“7”,“8”,“9”,“10”,“J”,“Q”,“K”,“A”,“2”
 *  花色: “♠”, “♥”, “♣”, "♦“
 *  大小王: “?” , "?“
 *  斗地主：发出 51 张牌，剩下 3 张做为底牌

**分析实现**

*  在启动游戏房间的时候，应该提前准备好 54 张牌
 *  接着，需要完成洗牌、发牌、对牌排序、看牌

**代码示例**

**Card.java**

// 牌类
    public class Card {
        
        private String number;      // 点数
        private String color;       // 花色
        private int size;           // 每张牌的大小
    
        public Card() {
        
        }
    
        public Card(String number, String color, int size) {
        
            this.number = number;
            this.color = color;
            this.size = size;
        }
    
        public String getNumber() {
        
            return number;
        }
    
        public void setNumber(String number) {
        
            this.number = number;
        }
    
        public String getColor() {
        
            return color;
        }
    
        public void setColor(String color) {
        
            this.color = color;
        }
    
        public int getSize() {
        
            return size;
        }
    
        public void setSize(int size) {
        
            this.size = size;
        }
    
        @Override
        public String toString() {
        
            return color + number ;
        }
    }

**Room.java**

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    // 房间类
    public class Room {
        
        // 首先要有一副牌
        private List<Card> allCards = new ArrayList<>();
    
        public Room(){
        
            // 1、做出54张牌，存入到集合allCards
            // a、点数：个数确定了，类型确定，点数从小到大排列
            String[] numbers = {
        "3","4","5","6","7","8","9","10","J","Q","K","A","2"};
    
            // b、花色：个数确定了，类型确定
            String[] colors = {
        "♠", "♥", "♣", "♦"};
            int size = 0; // 表示每张牌的大小
    
            // c、遍历点数，再遍历花色，组织牌
            for (String number : numbers) {
        
                // number = "3"
                size++; // 1 2 ....
                for (String color : colors) {
        
                    // 得到一张牌
                    Card c = new Card(number, color, size);
                    allCards.add(c); // 存入牌
                }
            }
    
            // 单独存入大小王的
            Card c1 = new Card("",  "?", ++size);
            Card c2 = new Card("", "?", ++size);
            Collections.addAll(allCards, c1, c2);
            System.out.println("新牌：" + allCards);
        }
    
        /**
         * 启动游戏
         */
        public void start() {
        
            // 1、洗牌
            Collections.shuffle(allCards);
            System.out.println("洗牌后：" + allCards);
    
            // 2、发牌，首先肯定要定义三个玩家。 List(ArrayList)  Set(TreeSet)
            List<Card> linHuChong = new ArrayList<>();
            List<Card> jiuMoZhi = new ArrayList<>();
            List<Card> renYingYing = new ArrayList<>();
    
            // 正式发牌给这三个玩家，依次发出51张牌，剩余3张做为底牌
            // allCards = [♥3, ♣10, ♣4, ♥K, ♦Q, ♣2, ?, ♣8, ....
            for (int i = 0; i < allCards.size() - 3; i++) {
        
                Card c = allCards.get(i);
                // 判断牌发给谁
                if(i % 3 == 0){
        
                    linHuChong.add(c);
                }else if(i % 3 == 1){
        
                    jiuMoZhi.add(c);
                }else {
        
                    renYingYing.add(c);
                }
            }
    
            // 3、对3个玩家的牌进行排序
            sortCards(linHuChong);
            sortCards(jiuMoZhi);
            sortCards(renYingYing);
    
            // 4、看牌
            System.out.println("啊冲：" + linHuChong);
            System.out.println("啊鸠：" + jiuMoZhi);
            System.out.println("盈盈：" + renYingYing);
    
            List<Card> lastThreeCards = allCards.subList(allCards.size() - 3, allCards.size());
            System.out.println("底牌：" + lastThreeCards);
    
            jiuMoZhi.addAll(lastThreeCards);
            sortCards(jiuMoZhi);
            System.out.println("啊鸠抢到地主后：" + jiuMoZhi);
        }
    
        /**
         * 集中进行排序
         * @param cards
         */
        private void sortCards(List<Card> cards) {
        
            Collections.sort(cards, (o1, o2) -> {
        
                return o2.getSize() - o1.getSize(); // 降序排序
            });
        }
    }

**GameDemo.java**

public class GameDemo {
        
        public static void main(String[] args) {
        
            //  1、牌类
            //  2、房间
            Room m = new Room();
            //  3、启动游戏
            m.start();
        }
    }

**执行结果**

![在这里插入图片描述][e13f4549103647f886026a6aae7b17ab.png]

## Map集合 ##

### 概述 ###

**认识Map集合**

*  Map 集合称为双列集合，格式为`{key1=value1, key2=value2, key3=value3, ...}`，一次需要存一对数据作为一个元素
 *  Map 集合的每个元素 “key=value” 称为一个键值对 / 键值对对象 / 一个 Entry 对象，Map 集合也被叫做 ”键值对集合“
 *  Map 集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值

**Map集合的应用场景**

当我们需要存储一一对应的数据时，就可以考虑使用 Map 集合来做

**Map集合体系**  
![在这里插入图片描述][ab62d0ca4763433189583489dca1d3a7.png]  
**Map集合体系的特点**

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

*  HashMap（由键决定特点）：无序、不重复、无索引（用得最多）
 *  LinkedHashMap（由键决定特点）：有序、不重复、无索引
 *  TreeMap（由键决定特点）：按照大小默认升序排序、不重复、无索引

**具体应用**

import java.util.LinkedHashMap;
    import java.util.Map;
    import java.util.TreeMap;
    
    /**
     * 目标：掌握Map集合的特点
     */
    public class MapTest1 {
        
        public static void main(String[] args) {
        
            // Map<String, Integer> map = new HashMap<>(); // 一行经典代码。 按照键 无序，不重复，无索引
            Map<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);
    
            Map<Integer, String> map1 = new TreeMap<>(); // 可排序，不重复，无索引
            map1.put(23, "Java");
            map1.put(23, "MySQL");
            map1.put(19, "李四");
            map1.put(20, "王五");
            System.out.println(map1);
        }
    }

![在这里插入图片描述][165768088d4142f8be579252c7d77a64.png]

### 常用方法 ###

**Map的常用方法如下：**  
![在这里插入图片描述][4760190869e54c7489f6b072ca377a54.png]

**具体应用**

import java.util.*;
    
    /**
     * 目标：掌握Map集合的常用方法
     */
    public class MapTest2 {
        
        public static void main(String[] args) {
        
            // 1.添加元素: 无序，不重复，无索引
            Map<String, Integer> map = new HashMap<>();
            map.put("手表", 100);
            map.put("手表", 220);
            map.put("手机", 2);
            map.put("Java", 2);
            map.put(null, null);
            System.out.println(map);
    
            // 2.public int size():获取集合的大小
            System.out.println("map.size: " + map.size());
    
            // 3、public void clear():清空集合
            //map.clear();
            //System.out.println(map);
    
            // 4.public boolean isEmpty(): 判断集合是否为空，为空返回true ,反之！
            System.out.println("map.isEmpty: " + map.isEmpty());
    
            // 5.public V get(Object key)：根据键获取对应值
            int v1 = map.get("手表");
            System.out.println("v1: " + v1);
            System.out.println(map.get("手机")); // 2
            System.out.println(map.get("张三")); // null
    
            // 6. public V remove(Object key)：根据键删除整个元素(删除键会返回键的值)
            System.out.println("map.remove(\"手表\"): " + map.remove("手表"));
            System.out.println(map);
    
            // 7.public  boolean containsKey(Object key): 判断是否包含某个键 ，包含返回true ,反之
            System.out.println(map.containsKey("手表")); // false
            System.out.println(map.containsKey("手机")); // true
            System.out.println(map.containsKey("java")); // false
            System.out.println(map.containsKey("Java")); // true
    
            // 8.public boolean containsValue(Object value): 判断是否包含某个值
            System.out.println(map.containsValue(2)); // true
            System.out.println(map.containsValue("2")); // false
    
            // 9.public Set<K> keySet(): 获取Map集合的全部键
            Set<String> keys = map.keySet();
            System.out.println("keys: " + keys);
    
            // 10.public Collection<V> values(); 获取Map集合的全部值
            Collection<Integer> values = map.values();
            System.out.println("values: " + values);
    
            // 11.把其他Map集合的数据倒入到自己集合中来(拓展)
            Map<String, Integer> map1 = new HashMap<>();
            map1.put("java1",  10);
            map1.put("java2",  20);
            Map<String, Integer> map2 = new HashMap<>();
            map2.put("java3",  10);
            map2.put("java2",  222);
            map1.putAll(map2); // putAll：把map2集合中的元素全部倒入一份到map1集合中去
            System.out.println("map1: " + map1);
            System.out.println("map2: " + map2);
        }
    }

![在这里插入图片描述][4c9b594abf6a430793cd84c6ccbcba21.png]

### 遍历方式 ###

**Map集合的遍历方式**

1.  **键找值**：先获取 Map 集合全部的键，再通过遍历键来找值
2.  **键值对**：把 “键值对” 看成一个整体进行遍历（难度较大）
3.  **Lambda**：JDK1.8 开始之后的新技术（非常简单）

**方式一：键找值**

需要用到 Map 的如下方法：  
![在这里插入图片描述][b5c93bd2252341bf95c299a93e1ed027.png]  
具体应用：

import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     *  目标：掌握Map集合的遍历方式1：键找值
     */
    public class MapTest1 {
        
        public static void main(String[] args) {
        
            // 准备一个Map集合
            Map<String, Double> map = new HashMap<>();
            map.put("蜘蛛精", 162.5);
            map.put("蜘蛛精", 169.8);
            map.put("紫霞", 165.8);
            map.put("至尊宝", 169.5);
            map.put("牛魔王", 183.6);
            System.out.println("map: " + map);
    
            // 1、获取Map集合的全部键
            Set<String> keys = map.keySet();
             System.out.println("keys: " + keys);
    
            // 2、遍历全部的键，根据键获取其对应的值
            for (String key : keys) {
        
                // 根据键获取对应的值
                double value = map.get(key);
                System.out.println(key + "=====>" + value);
            }
        }
    }

![在这里插入图片描述][5fd0a40c959a4bd8a128b606097b05e7.png]

**方式二：键值对**

需要用到 Map 和 Map.Entry 的如下方法：  
![在这里插入图片描述][8c9a7654a020435ab0adf2e783dfc19f.png]

具体应用：

import java.util.*;
    /**
     * 目标：掌握Map集合的第二种遍历方式：键值对
     */
    public class MapTest2 {
        
        public static void main(String[] args) {
        
            Map<String, Double> map = new HashMap<>();
            map.put("蜘蛛精", 169.8);
            map.put("紫霞", 165.8);
            map.put("至尊宝", 169.5);
            map.put("牛魔王", 183.6);
            System.out.println(map);
    
            // 1、调用Map集合提供entrySet方法，把Map集合转换成键值对类型的Set集合
            Set<Map.Entry<String, Double>> entries = map.entrySet();
            for (Map.Entry<String, Double> entry : entries) {
        
                String key = entry.getKey();
                double value = entry.getValue();
                System.out.println(key + "=====>" + value);
            }
        }
    }

![在这里插入图片描述][07f00f0396f74b63850d87827a67628d.png]

**方式三：Lambda**

需要用到 Map 的如下方法：  
![在这里插入图片描述][c2ce62daa1b74820be82b29b7eb15ca6.png]

具体应用：

import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 目标：掌握Map集合的第三种遍历方式：Lambda
     */
    public class MapTest3 {
        
        public static void main(String[] args) {
        
            Map<String, Double> map = new HashMap<>();
            map.put("蜘蛛精", 169.8);
            map.put("紫霞", 165.8);
            map.put("至尊宝", 169.5);
            map.put("牛魔王", 183.6);
            System.out.println(map);
    
            map.forEach(( k,  v) -> {
        
                  System.out.println(k + "=====>" + v);
            });
        }
    }

![在这里插入图片描述][656bd9b03bdb48a699f0c7dd66363f58.png]

**案例：统计投票人数**

**需求**

某个班级有 80 名学生，现在需要组织秋游活动，班长提供了四个景点依次是 A、B、C、D，每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多

**分析**

1.  将 80 个学生选择的数据拿到程序中去
2.  准备一个 Map 集合用于存储统计的结果，Map<String, Integer>，键是景点，值代表投票数量
3.  遍历 80 个学生选择的景点，每遍历一个景点，就看 Map 集合中是否存在该景点，不存在则存入 “景点=1”，存在则其对应值+1

**代码示例**

import java.util.*;
    
    /**
     * 目标：案例：统计投票人数
     */
    public class MapDemo4 {
        
        public static void main(String[] args) {
        
            // 1、把80个学生选择的景点数据拿到程序中来
            List<String> data = new ArrayList<>();
            String[] selects = {
        "A", "B", "C", "D"};
            Random r = new Random();
            for (int i = 1; i <= 80; i++) {
        
                // 每次模拟一个学生选择一个景点，存入到集合中去
                int index = r.nextInt(4); // 0 1 2 3
                data.add(selects[index]);
            }
            System.out.println(data);
    
            // 2、开始统计每个景点的投票人数
            // 准备一个Map集合用于统计最终的结果
            Map<String, Integer> result = new HashMap<>();
    
            // 3、开始遍历80个景点数据
            for (String s : data) {
        
                // 问问Map集合中是否存在该景点
                if(result.containsKey(s)){
        
                    // 说明这个景点之前统计过。其值+1. 存入到Map集合中去
                    result.put(s, result.get(s) + 1);
                }else {
        
                    // 说明这个景点是第一次统计，存入"景点=1"
                    result.put(s, 1);
                }
            }
            System.out.println(result);
        }
    }

![在这里插入图片描述][7e339270188a48058e99c843013a171f.png]

### HashMap ###

**HashMap集合的底层原理**

HashMap 跟 HashSet 的底层原理是一模一样的，都是基于哈希表实现的

实际上，原来学的 Set 系列集合的底层就是基于 Map 实现的，只是 Set 集合中的元素只要键数据，不要值数据而已

HashMap 的底层是利用键来计算哈希值的，和值无关

**HashMap集合总结**

*  HashMap 集合是一种增删改查数据性能都比较好的集合
 *  但是它是无序的、不重复的、无索引支持的（由键决定特点）
 *  HashMap 的键依赖 hashCode 方法和 equals 方法保证键的唯一
 *  如果键存储的是自定义类型的对象，可以通过重写 hashCode 和 equals 方法，这样可以保证多个对象内容一样时，HashMap 集合就能认为是重复的

**案例：HashMap集合存储自定义对象并遍历**

**需求**

创建一个 HashMap 集合，键是学生对象 Student，值是籍贯，存储几个键值对元素并遍历

**分析**

1.  定义一个学生类
2.  创建 HashMap 集合对象
3.  创建学生对象
4.  把学生添加到集合
5.  遍历集合

**代码示例**

**Student.java**

import java.util.Objects;
    
    public class Student implements Comparable<Student> {
        
        private String name;
        private int age;
        private double height;
    
        @Override
        public int compareTo(Student o) {
        
            return this.age - o.age; // 年龄升序排序
        }
    
        @Override
        public 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 && Double.compare(student.height, height) == 0 && Objects.equals(name, student.name);
        }
    
        @Override
        public int hashCode() {
        
            return Objects.hash(name, age, height);
        }
    
        public Student() {
        
        }
    
        public Student(String name, int age, double height) {
        
            this.name = name;
            this.age = age;
            this.height = height;
        }
    
    
        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 double getHeight() {
        
            return height;
        }
    
        public void setHeight(double height) {
        
            this.height = height;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", height=" + height +
                    '}';
        }
    }

**TestHashMap.java**

import java.util.HashMap;
    import java.util.Map;
    
    public class TestHashMap {
        
        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), "牛头山");
            map.forEach((k, v) -> System.out.println(k + ", " +v));
        }
    }

![在这里插入图片描述][1f68ad38d54f46d18eb8dd2f80869b58.png]

### LinkedHashMap ###

**LinkedHashMap集合的底层原理**

底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外地多了一个双链表的机制记录元素顺序，目的是保证元素的有序

实际上，我们原来学习的 LinkedHashSet 集合的底层原理就是 LinkedHashMap

**具体应用**

import java.util.LinkedHashMap;
    
    /**
     * 目标：掌握LinkedHashMap的底层原理
     */
    public class TestLinkedHashMap {
        
        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);
        }
    }

![在这里插入图片描述][35a81ed5460b477babdb5b1ef3f85b0e.png]

### TreeMap ###

**TreeMap**

*  特点：不重复、无索引、可排序（按照键的大小默认升序排序，只能对键排序）
 *  原理：TreeMap 跟 TreeSet 集合的底层原理是一样的，都是基于红黑树实现的排序

**TreeMap集合同样也支持两种方式来指定排序规则**

*  让类实现 Comparable 接口，重写比较规则
 *  TreeMap 集合有一个参数构造器，支持创建 Comparator 比较器对象，以便用来指定比较规则

**具体应用**

import java.util.Comparator;
    import java.util.Map;
    import java.util.TreeMap;
    
    /**
     * 目标：掌握TreeMap集合的使用
     */
    public class TestTreeMap {
        
        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(o2.getHeight(), o1.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), "牛头山");
    
            map.forEach((k, v) -> System.out.println(k + ", " + v));
        }
    }

![在这里插入图片描述][cfa9bf52d790419c813cbe2bc823ca4e.png]

### 集合的嵌套 ###

**什么是集合嵌套 ？**

指的是集合中的元素又是一个集合

**Map集合实现类特点**

*  HashMap：元素按照键是无序、不重复、无索引、值不做要求、基于哈希表
 *  LinkedHashMap：元素按照键是有序、不重复、无索引、值不做要求、基于哈希表
 *  TreeMap：元素只能按照键排序、不重复、无索引、值不做要求、可以做排序

**Map集合案例-省和市**

**需求**

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

*  江苏省 = 南京市，扬州市，苏州市，无锡市，常州市  
    湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市  
    河北省 = 石家庄市，唐山市，邢台市，保定市，张家口

**分析**

*  定义一个 Map 集合，键表示省份名称，值表示城市名称，注意有多个城市
 *  根据 “湖北省” 这个键获取对应的值展示即可

**代码示例**

import java.util.*;
    
    /**
     * 目标：理解集合的嵌套
     */
    public class Test {
        
        public static void main(String[] args) {
        
            // 1、定义一个Map集合存储全部的省份信息，和其对应的城市信息
            Map<String, List<String>> map = new HashMap<>();
    
            List<String> cities1 = new ArrayList<>();
            Collections.addAll(cities1, "南京市","扬州市","苏州市" ,"无锡市","常州市");
            map.put("江苏省", cities1);
    
            List<String> cities2 = new ArrayList<>();
            Collections.addAll(cities2, "武汉市","孝感市","十堰市","宜昌市","鄂州市");
            map.put("湖北省", cities2);
    
            List<String> cities3 = new ArrayList<>();
            Collections.addAll(cities3, "石家庄市","唐山市", "邢台市", "保定市", "张家口市");
            map.put("河北省", cities3);
    
            map.forEach((k, v) -> System.out.println(k + " = " + v));
    
            List<String> cities = map.get("湖北省");
            for (String city : cities) {
        
                System.out.println(city);
            }
        }
    }

![在这里插入图片描述][cdfb903fab6542df936e6436faa73eb3.png]

## JDK8新特性：Stream流 ##

### 认识Stream ###

**什么是 Stream ?**

*  也叫做 Stream 流，是 JDK8 开始新增的一套 API（java.util.stream.\*），可以用于操作集合或者数组的数据
 *  优势：Stream 流大量地结合了 Lambda 的语法风格来编程，提供了一种更加强大、更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好

**案例：体验Stream流**

**需求**

List<String> names = new ArrayList<>();
    Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");

把集合中所有以 “张” 开头，且是 3 个字的元素存储到一个新的集合中

**代码示例**

import java.util.*;
    import java.util.stream.Collectors;
    
    /**
       目标：初步体验Stream流的方便与快捷
     */
    public class StreamTest1 {
        
        public static void main(String[] args) {
        
            List<String> names = new ArrayList<>();
            Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
            System.out.println(names);
    
            // 找出姓张，且是3个字的名字，存入到一个新集合中去
            List<String> list = new ArrayList<>();
            for (String name : names) {
        
                if(name.startsWith("张") && name.length() == 3){
        
                    list.add(name);
                }
            }
            System.out.println("一般方式: " + list);
    
            // 开始使用Stream流来解决这个需求
            List<String> list2 = names.stream().filter(s -> s.startsWith("张"))
                    .filter(a -> a.length()==3).collect(Collectors.toList());
            System.out.println("Stream流: " + list2);
        }
    }

![在这里插入图片描述][b822410594bd427ebe5787230dfb648b.png]

**Stream流的使用步骤**

![在这里插入图片描述][d5c169fa07644ce69bfd7a6f32de447c.png]

### Stream的常用方法 ###

![在这里插入图片描述][25294f62453841dcaffb0f8cc9bf6a19.png]

**1、获取Stream流**

*  获取集合的 Stream 流  
    ![在这里插入图片描述][c75d451d8bbd4220b61ac88301e7d8a9.png]
 *  获取数组的 Stream 流  
    ![在这里插入图片描述][a9180258a62e4b70951140542099cbd4.png]

import java.util.*;
    import java.util.stream.Stream;
    
    /**
     * 目标：掌握Stream流的创建
     */
    public class StreamTest2 {
        
        public static void main(String[] args) {
        
            // 1、如何获取List集合的Stream流？
            List<String> names = new ArrayList<>();
            Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
            Stream<String> stream = names.stream();
    
            // 2、如何获取Set集合的Stream流？
            Set<String> set = new HashSet<>();
            Collections.addAll(set, "刘德华","张曼玉","蜘蛛精","马德","德玛西亚");
            Stream<String> stream1 = set.stream();
            stream1.filter(s -> s.contains("德")).forEach(System.out::println);
    
            // 3、如何获取Map集合的Stream流？
            Map<String, Double> map = new HashMap<>();
            map.put("古力娜扎", 172.3);
            map.put("迪丽热巴", 168.3);
            map.put("马尔扎哈", 166.3);
            map.put("卡尔扎巴", 168.3);
    
            Set<String> keys = map.keySet();
            Stream<String> ks = keys.stream();
    
            Collection<Double> values = map.values();
            Stream<Double> vs = values.stream();
    
            Set<Map.Entry<String, Double>> entries = map.entrySet();
            Stream<Map.Entry<String, Double>> kvs = entries.stream();
            kvs.filter(e -> e.getKey().contains("巴"))
                    .forEach(e -> System.out.println(e.getKey()+ "-->" + e.getValue()));
    
            // 4、如何获取数组的Stream流？
            String[] names2 = {
        "张翠山", "东方不败", "唐大山", "独孤求败"};
            Stream<String> s1 = Arrays.stream(names2);
            Stream<String> s2 = Stream.of(names2);
        }
    }

![在这里插入图片描述][29b00e03f2d44835820064756c895665.png]

**2、Stream流常见的中间方法**

中间方法指的是调用完成后会返回新的 Stream 流，可以继续使用（支持链式编程）  
![在这里插入图片描述][89a2c3a9c3be4c799d8420ce94231adf.png]

Student 类和前面的一样

import java.util.*;
    import java.util.stream.Stream;
    
    /**
     * 目标：掌握Stream流提供的常见中间方法
     */
    public class StreamTest3 {
        
        public static void main(String[] args) {
        
            List<Double> scores = new ArrayList<>();
            Collections.addAll(scores, 88.5, 100.0, 60.0, 99.0, 9.5, 99.6, 25.0);
    
            // 需求1：找出成绩大于等于60分的数据，并升序后，再输出
            scores.stream().filter(s -> s >= 60).sorted().forEach(System.out::println);
    
            List<Student> students = new ArrayList<>();
            Student s1 = new Student("蜘蛛精", 26, 172.5);
            Student s2 = new Student("蜘蛛精", 26, 172.5);
            Student s3 = new Student("紫霞", 23, 167.6);
            Student s4 = new Student("白晶晶", 25, 169.0);
            Student s5 = new Student("牛魔王", 35, 183.3);
            Student s6 = new Student("牛夫人", 34, 168.5);
            Collections.addAll(students, s1, s2, s3, s4, s5, s6);
    
            // 需求2：找出年龄大于等于23,且年龄小于等于30岁的学生，并按照年龄降序输出
            students.stream().filter(s -> s.getAge() >= 23 && s.getAge() <= 30)
                    .sorted((o1, o2) -> o2.getAge() - o1.getAge())
                    .forEach(System.out::println);
    
            // 需求3：取出身高最高的前3名学生，并输出
            students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
                    .limit(3).forEach(System.out::println);
            System.out.println("----------------------------------------------------------------");
    
            // 需求4：取出身高倒数的2名学生，并输出。   s1 s2 s3 s4 s5 s6
            students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
                    .skip(students.size() - 2).forEach(System.out::println);
    
            // 需求5：找出身高超过168的学生叫什么名字，要求去除重复的名字，再输出
            students.stream().filter(s -> s.getHeight() > 168).map(Student::getName)
                   .distinct().forEach(System.out::println);
    
            // distinct去重复，自定义类型的对象（希望内容一样就认为重复，重写hashCode,equals）
            students.stream().filter(s -> s.getHeight() > 168)
                    .distinct().forEach(System.out::println);
    
            Stream<String> st1 = Stream.of("张三", "李四");
            Stream<String> st2 = Stream.of("张三2", "李四2", "王五");
            Stream<String> allSt = Stream.concat(st1, st2);
            allSt.forEach(System.out::println);
        }
    }

**3、Stream流常见的终结方法**

终结方法指的是调用完成后，不会返回新的 Stream 了，没法继续使用流了  
![在这里插入图片描述][ab1a2902da044e51963d4008b4b703b7.png]

收集 Stream 流：就是把 Stream 流操作后的结果转回到集合或者数组中去返回

Stream 流：方便操作集合或数组的手段；集合 / 数组：才是开发中的目的

![在这里插入图片描述][f911bd90a12646f89d1ff08f3a3ff99b.png]

import java.util.*;
    import java.util.stream.Collectors;
    
    /**
     * 目标：Stream流的终结方法
     */
    public class StreamTest4 {
        
        public static void main(String[] args) {
        
            List<Student> students = new ArrayList<>();
            Student s1 = new Student("蜘蛛精", 26, 172.5);
            Student s2 = new Student("蜘蛛精", 26, 172.5);
            Student s3 = new Student("紫霞", 23, 167.6);
            Student s4 = new Student("白晶晶", 25, 169.0);
            Student s5 = new Student("牛魔王", 35, 183.3);
            Student s6 = new Student("牛夫人", 34, 168.5);
            Collections.addAll(students, s1, s2, s3, s4, s5, s6);
    
            // 需求1：请计算出身高超过168的学生有几人
            long size = students.stream().filter(s -> s.getHeight() > 168).count();
            System.out.println(size);
    
            // 需求2：请找出身高最高的学生对象，并输出
            Student s = students.stream().max((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
            System.out.println(s);
    
            // 需求3：请找出身高最矮的学生对象，并输出
            Student ss = students.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
            System.out.println(ss);
    
            // 需求4：请找出身高超过170的学生对象，并放到一个新集合中去返回
            // 流只能收集一次
            List<Student> students1 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toList());
            System.out.println(students1);
    
            Set<Student> students2 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toSet());
            System.out.println(students2);
    
            // 需求5：请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合返回
            Map<String, Double> map =
                    students.stream().filter(a -> a.getHeight() > 170)
                            .distinct().collect(Collectors.toMap(a -> a.getName(), a -> a.getHeight()));
            System.out.println(map);
    
            // Object[] arr = students.stream().filter(a -> a.getHeight() > 170).toArray();
            Student[] arr = students.stream().filter(a -> a.getHeight() > 170).toArray(len -> new Student[len]);
            System.out.println(Arrays.toString(arr));
        }
    }

[Link 1]: https://blog.csdn.net/weixin_62511863?spm=1011.2421.3001.5343
[Java]: https://blog.csdn.net/weixin_62511863/category_12365679.html?spm=1001.2014.3001.5482
[a1553c59aa244bc2b33bd75705ca9e81.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/021a03539a5444e681dac16e1ab6e90b.png
[200905f1d06e4ce3aebafc5ecadbb797.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/469370f0d6bc4fb8acb475cb6b4ddb74.png
[52813b2799a540f19a2a3b4bea85ef03.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/b41ac788006b443094e57431652355a4.png
[e13f4549103647f886026a6aae7b17ab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7ae944a096b34f4e872d38ad83e53e6f.png
[ab62d0ca4763433189583489dca1d3a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7c7f6d03bc324369bac306b0858ffa6b.png
[165768088d4142f8be579252c7d77a64.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/70cc7ac0813442c7b7faa78701dcdbc8.png
[4760190869e54c7489f6b072ca377a54.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c10ff8d96cae4d658edb27abba71d4d5.png
[4c9b594abf6a430793cd84c6ccbcba21.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/2cb7cb095b614a80981153993410e8f1.png
[b5c93bd2252341bf95c299a93e1ed027.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/b9ba1006e12a4da8991ddf295c9af54b.png
[5fd0a40c959a4bd8a128b606097b05e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8fa71c0851d145a2bc39cb7ee81ddcda.png
[8c9a7654a020435ab0adf2e783dfc19f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c1c10cd895884695af3cb4e8e225bdaa.png
[07f00f0396f74b63850d87827a67628d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/ab6f69e260a946cfba79a67b1f090e8f.png
[c2ce62daa1b74820be82b29b7eb15ca6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/f660b7f381fa4f908f177d6399d10b26.png
[656bd9b03bdb48a699f0c7dd66363f58.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/474b761545dd4149866d932f5789e928.png
[7e339270188a48058e99c843013a171f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/f3544040b6364087a69568bb71f87c3d.png
[1f68ad38d54f46d18eb8dd2f80869b58.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/faa02f0563564ae7b5a49cc3d81da7a7.png
[35a81ed5460b477babdb5b1ef3f85b0e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/25136c4ef52745e4a36b2024501a7427.png
[cfa9bf52d790419c813cbe2bc823ca4e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/acdc763c7dc14601ba413e0b0459b452.png
[cdfb903fab6542df936e6436faa73eb3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/95fef969974d45299af7ad1baa9bd697.png
[b822410594bd427ebe5787230dfb648b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/ce6fff97f58e43eda97e46f68eda0844.png
[d5c169fa07644ce69bfd7a6f32de447c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/aa79d97b76c943b2827406744d6a29e2.png
[25294f62453841dcaffb0f8cc9bf6a19.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/ff340845a8604898a107d3876d852faf.png
[c75d451d8bbd4220b61ac88301e7d8a9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0335fe578a3141468daf636dbbe22fc8.png
[a9180258a62e4b70951140542099cbd4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/073fd5dbea694352a4b587e9c91722c6.png
[29b00e03f2d44835820064756c895665.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/9e80a190fdf44004b7ee7419fa17d289.png
[89a2c3a9c3be4c799d8420ce94231adf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/3037c5f7ce384dcb9f3956c122c37746.png
[ab1a2902da044e51963d4008b4b703b7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1438a44666b243908e7c66798c02060a.png
[f911bd90a12646f89d1ff08f3a3ff99b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/533b29132c3749b1b837aad5215d108a.png