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

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("-----------------------------------------");
    }
}

Collections

什么是 Collections ？

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

Collections提供的常用静态方法

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);
    }
}

综合案例

案例：斗地主游戏

分析业务需求

• 总共有 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();
    }
}

执行结果

Map集合

概述

认识Map集合

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

Map集合的应用场景

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

Map集合体系

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);
    }
}

常用方法

Map的常用方法如下：

具体应用

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);
    }
}

遍历方式

Map集合的遍历方式

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

方式一：键找值

需要用到 Map 的如下方法：

具体应用：

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);
        }
    }
}

方式二：键值对

需要用到 Map 和 Map.Entry 的如下方法：

具体应用：

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);
        }
    }
}

方式三：Lambda

需要用到 Map 的如下方法：

具体应用：

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);
        });
    }
}

案例：统计投票人数

需求

某个班级有 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);
    }
}

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));
    }
}

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);
    }
}

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));
    }
}

集合的嵌套

什么是集合嵌套 ？

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

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);
        }
    }
}

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);
    }
}

Stream流的使用步骤

Stream的常用方法

1、获取Stream流

• 获取集合的 Stream 流
  
• 获取数组的 Stream 流
  

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);
    }
}

2、Stream流常见的中间方法

中间方法指的是调用完成后会返回新的 Stream 流，可以继续使用（支持链式编程）

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 了，没法继续使用流了

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

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

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));
    }
}