集合和Stream流

一.Collection集合

1.Collection的常用方法

1.add

先创建一个集合

        Collection<String> collection = new ArrayList<>();

add：把给定的对象添加到当前集合中

        collection.add("java1");
        collection.add("java2");
        collection.add("java1");
        collection.add("java2");
        collection.add("java3");
        System.out.println(collection);

打印结果：
[java1, java2, java1, java2, java3]

2.size

返回集合中的元素的个数

        System.out.println(collection.size());

打印结果：
5

3.remove

把给定的对象在当前集合中删除（若有重复的元素，默认删除的是第一个）

        System.out.println(collection.remove("java2"));
        System.out.println(collection);

打印结果：
true
[java1, java1, java2, java3]

4.contains

判断当前集合中是否包含给定的对象

        System.out.println(collection.contains("java1"));

打印结果：
true

5.isEmpty

判断当前集合是否为空

        System.out.println(collection.isEmpty());

打印结果：
false

6.public Object[] toArray():

把集合转换成数组

        Object[] array = collection.toArray();
        System.out.println(Arrays.toString(array));

打印结果：
[java1, java1, java2, java3]

7.addAll

把一个集合中的全部数据倒入到另一个集合中去

        Collection<String> c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String> c2 = new ArrayList<>();
        c2.add("java3");
        c2.add("java4");
        c1.addAll(c2);
        System.out.println(c1);
        System.out.println(c2);

此处把c2中的元素倒入到c1中，仅是把c2中的元素复制一份给c1，而c2中的元素不变

执行结果：
[java1, java2, java3, java4]
[java3, java4]

8.clear

清空集合中所有的元素

        collection.clear();
        System.out.println(collection);

结果为：[]

2.Collection集合的遍历方式

先创建一个集合

        Collection<String> collection = new ArrayList<>();
        collection.add("赵敏");
        collection.add("小昭");
        collection.add("素素");
        collection.add("灭绝");
        System.out.println(collection);
        // 【赵敏，小昭， 殷素素，周芷若】

1.使用迭代器

1. 从集合对象中获取迭代器对象

        Iterator<String> iterator = collection.iterator();

2. 我们应该使用循环结合迭代器遍历集合

        while (iterator.hasNext()){
            String ele = iterator.next();
            System.out.println(ele);
        }

2.使用增强for

使用增强for遍历集合

        for (String ele : collection){
            System.out.println(ele);
        }

拓展：使用增强for遍历数组

        String[] names = {"迪丽热巴","古力娜扎","嘻嘻哈哈"};
        for (String ele : names){
            System.out.println(ele);
        }

3.使用ForEach，结合Lambda表达式遍历集合

        collection.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

简化

        collection.forEach((String s)-> {
                System.out.println(s);
        });

再简化

        collection.forEach( s-> System.out.println(s));

最后

        collection.forEach(System.out::println);

1.List系列集合

特点：添加的元素是有序，可重复，有索引

1.Arraylist集合

1. 先创建一个Array List集合对象（有序，可重复，有索引）

        List<String> list = new ArrayList<>();
        list.add("蜘蛛精");
        list.add("至尊宝");
        list.add("至尊宝");
        list.add("牛夫人");
        System.out.println(list);// [蜘蛛精，至尊宝，至尊宝，牛夫人]

2. public void add(int index, E element): 在某个索引位置插入元素

        list.add(2,"紫霞仙子");
        System.out.println(list);
        // [蜘蛛精, 至尊宝, 紫霞仙子, 至尊宝, 牛夫人]

3. public E remove(int index): 根据索引删除元素，返回被删除元素

        System.out.println(list.remove(2));
        System.out.println(list);
        // 紫霞仙子
		// [蜘蛛精, 至尊宝, 至尊宝, 牛夫人]

4. public E get(int index): 返回集合中指定位置的元素

        System.out.println(list.get(3));
        // 牛夫人

5. public E set(int index, E element): 修改索引位置处的元素，修改成功后，会返回原来的数据

        System.out.println(list.set(3,"牛魔王"));
        System.out.println(list);
        // 牛夫人
		// [蜘蛛精, 至尊宝, 至尊宝, 牛魔王]

2.LinkedList

创建一个队列（先进先出，后进后出）

        // 1.创建一个队列
        LinkedList<String> queue = new LinkedList<>();
        // 入队
        queue.add("第一号人");
        queue.add("第二号人");
        queue.add("第三号人");
        queue.add("第四号人");
        System.out.println(queue);
        // 出队
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);

创建一个栈（先进后出，后进先出）

        LinkedList<String> stack = new LinkedList<>();
        // 压栈(push)
        stack.push("第一颗子弹");
        stack.push("第二颗子弹");
        stack.push("第三颗子弹");
        stack.push("第四颗子弹");
        System.out.println(stack);
        // 出栈(pop)
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack);

1.set系列集合

特点：无序：添加数据的顺序和获取出的数据顺序不一致；不重复；无索引

• HashSet：无序，不重复，无索引
• LinkedHashSet：有序，不重复，无索引
• TreeSet：排序，不重复，无索引

哈希值

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

public int hashCode(); 返回对象的哈希码值
对象哈希值的特点

• 同一个对象调用hashCode()方法返回的哈希值是相同的
• 不同的对象，它们的哈希值一般不相同，但也可能会相同（哈希碰撞）

        Student s1 = new Student("蜘蛛精",25,169.5);
        Student s2 = new Student("紫霞",22,166.5);
        System.out.println(s1.hashCode());
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        String str1 = new String("abc");
        String str2 = new String("acD");
        System.out.println(str1.hashCode());
        System.out.println(str2.hashCode());

输出的哈希值：
1163157884
1163157884
1956725890
96354
96354

1.HashSet

• 创建一个默认长度16的数组，默认加载因子为0.75，数组名为table
• 使用元素的哈希值对数组的长度求余计算出应存入的位置
• 判断当前位置是否为null，如果是null直接存入
• 如果不为null，表示有元素，则调用equals方法比较。相等，则不存；不相等，则存入数组
• JDK8之前，新元素存入数组，占老元素位置，老元素挂下面
• JDK8开始之后，新元素直接挂在老元素下面
  应用:
  自定义的类型的对象,比如两个内容一样的学生对象,如果用Hashset集合能够去重复

public class SetTest3 {
    public static void main(String[] args) {
        Set<Student> students = new HashSet<>();
        Student s1 = new Student("至尊宝",28, 169.5);
        Student s2 = new Student("蜘蛛精",23, 169.5);
        Student s3 = new Student("蜘蛛精",23, 169.5);
        Student s4 = new Student("牛魔王",48, 169.6);
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        System.out.println(students);
    }
}

2.TreeSet

特点：不重复，无索引，可排序（默认升序排序，按照元素的大小，由小到大排序）
底层是基于红黑树实现的排序
注意：
对于数值类型：Integer，Double，默认按照数值本身的大小进行升序排序
对于字符串类型：默认按照首字符的编号升序排序
对于自定义类型如Student类型，TreeSet默认是无法直接排序的

• 对于自定义类型,可以通过两中方式定义比较规则去比较
• 1.实现Comparable接口,重写compareTo方法,在里面写按照什么进行升序或降序排列

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

    @Override
    public int compareTo(Student o) {
        // 如果认为左边对象大于右边对象返回正整数
        // 如果认为左边对象小于右边对象返回负整数
        // 如果认为左边对象等于右边对象返回0
        // 需求；按照年龄升序排序
        return this.age - o.age;
    }

• 此对于身高的比较,应该这样写

return Double.compare(this.getHeight(),o.getHeight());

• 2. 重写Comparator方法

       Set<Student> students = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getHeight(), o2.getHeight());
            }
        });

3.集合的并发修改异常问题

那些问题遍历存在问题?
迭代器遍历过程中,通过集合对象修改了集合中元素的长度,造成了迭代器获取元素中判断预期修改值和实际修改不一致

1. 迭代器遍历集合且直接用集合删除元素的时候可能出现
2. 增强for循环遍历集合且直接删除元素的时候可能出现
   可以使用for循环到着遍历,迭代器

public class CollectionTest1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("王麻子");
        list.add("小李子");
        list.add("李爱花");
        list.add("张全蛋");
        list.add("晓李");
        list.add("李玉刚");
        System.out.println(list);
        // [王麻子， 小李子， 李爱花， 张全蛋， 晓李， 李玉刚]

        // 需求：删除带李的名字
        // 1。使用for循环
        for (int i = 0; i < list.size() ; i++) {
            String name = list.get(i);
            if (name.contains("李")){
                list.remove(name);
                i--;
            }
        }
        System.out.println(list);

        // 2.使用for循环倒着遍历
        for (int i = list.size() - 1; i >0 ; i--) {
            String name = list.get(i);
            if (name.contains("李")){
                list.remove(name);
            }
        }
        System.out.println(list);

        // 3.使用迭代器遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String name = iterator.next();
            if (name.contains("李")){
                list.remove(name);
            }
        }
        System.out.println(list);
        
    }
}

4.可变参数

• 就是一种特殊形参，定义在方法，构造器的形参列表里，格式是：数据类型…参数名称；
  可变参数的特点和好处

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

• 好处：常常用来灵活的接收数据
  注意事项:

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

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

public class ParamTest {
    public static void main(String[] args) {
        // 特点
        test();
        test(10);
        test(10,20,30);
        test(new int[]{10, 20, 30, 40});
    }
    public static void test(int...nums){
        System.out.println(nums.length);
        System.out.println(Arrays.toString(nums));
        System.out.println("----------------------------");

为什么可变参数可以传多个数据?
因为可变参数在方法内部,本质上就是一个数组

二.Collections集合工具类

下面是对于上述方法的一些代码实现:

public class CollectionsTest1 {
    public static void main(String[] args) {
        // 1.public static <T> boolean addAll(Collections<? 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<?> List):对List集合中的元素进行升序排序
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(5);
        list.add(2);
        Collections.sort(list);
        System.out.println(list);

三，Map集合

1.认识Map集合

• Map集合称为双列集合，格式：{key1 = value1,key2 = value2,key3 = value3,…},一次需要存一对数据做为一个元素
• Map集合的每个元素“key = value”称为一个键值对/键值对对象/一个Entry对象，Map集合也被叫做“键值对集合”
• Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值
  Map集合体系的特点
  注意：Map系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的
• HashMap（由键决定特点）：无序，不重复，无索引；（用的最多）
• LinkedHashMap（由键决定特点）：有序，不重复，无索引
• TreeMap（由键决定特点）：按照大小默认升序排序，不重复，无索引

        // Map<String,Integer> map = new HashMap<>();// 一行经典代码，按照键，无序，不重复，无索引
        Map<String,Integer> map = new LinkedHashMap<>();// 有序，不重复，无索引
        map.put("java",2);
        map.put("java",9);// 后面重复的数据会覆盖前面的数据（键）
        map.put("SQL",2);
        map.put("手机",1);
        System.out.println(map);

        Map<Integer,String> map1 = new TreeMap<>();// 可排序，不重复，无索引
        map1.put(25,"java");
        map1.put(19,"javaWeb");
        map1.put(10,"java");// 默认从小到大升序排序
        System.out.println(map1);

2.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);
       //  map = [null = null , 手表 = 220 ，Java = 2 ，手机 = 2]

        // 2.public int size():获取集合的大小
        System.out.println(map.size());

        // 3.public void clear():清空集合
        // map.clear();
        // System.out.println(map);

        // 4.public boolean isEmpty():判断集合是否为空，为空返回true
        System.out.println(map.isEmpty());

        // 5.public V get(Object key):根据键获取对应值
        int v1 = map.get("手表");// 220
        System.out.println(v1);
        System.out.println(map.get("手机"));// 2
        System.out.println(map.get("张三"));// null

        // 6.public V remove(Object key):根据键删除整个元素（删除元素会返回键的值）
        System.out.println(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):判断是否包含某个值，包含返回true
        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);

        // 10.public Collection<V> values():获取Map集合的全部值
        Collection<Integer> values = map.values();
        System.out.println(values);

        // 11.把其他Map集合的数据倒入到自己集合中来
        Map<String,Integer> map1 = new HashMap();
        map1.put("java1" ,10);
        map1.put("java2" ,20);
        System.out.println(map1);
        Map<String,Integer> map2 = new HashMap();
        map2.put("java3" ,30);
        map2.put("java4" ,40);
        map1.putAll(map2);
        System.out.println(map1);
        System.out.println(map2);

3.Map集合的遍历方式

1.键找值

实现思路:

1. 先准备一个Map集合
2. 获取Map集合中的全部键
3. 遍历全部的键,根据键获取其对应的值
   代码实现

public class MapTest1 {
    public static void main(String[] args) {
        // 准备一个Map集合
        Map<String,Double> map = new HashMap<>();
        map.put("蜘蛛精", 162.5);
        map.put("蜘蛛精", 169.5);
        map.put("紫霞", 165.8);
        map.put("至尊宝", 169.5);
        map.put("牛魔王", 183.6);
        System.out.println(map);
        // map = {蜘蛛精=169.5, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}

        // 1.获取Map集合中的全部键
        Set<String> keys = map.keySet();
        System.out.println(keys);

        // 2.遍历全部的键，根据键获取其对应的值
        for (String key : keys) {
            // 根据键获取对应的值
            double value = map.get(key);
            System.out.println(key + "====>" + value);
        }
    }
}

2.键值对

实现思路:

1. 准备一个Map集合
2. 调用Map集合中的entrySet方法,把Map集合转换成键值对类型的Set集合
   代码实现

public class MapTest2 {
    public static void main(String[] args) {
        Map<String,Double> map = new HashMap<>();
        map.put("蜘蛛精", 169.5);
        map.put("紫霞", 165.8);
        map.put("至尊宝", 169.5);
        map.put("牛魔王", 183.6);
        System.out.println(map);
        // map = {蜘蛛精=169.5, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}

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

3.使用Lambda表达式

直接上代码

public class MapTest3 {
    public static void main(String[] args) {
        Map<String,Double> map = new HashMap<>();
        map.put("蜘蛛精", 169.5);
        map.put("紫霞", 165.8);
        map.put("至尊宝", 169.5);
        map.put("牛魔王", 183.6);
        System.out.println(map);
        // map = {蜘蛛精=169.5, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}

        map.forEach((k,v) -> {
            System.out.println(k + "---->" + v);
        });
    }
}

4.Map集合的分支

1.HashSet

2.TreeMap

• 对于自定义类型,可以通过两中方式定义比较规则去比较
• 1.实现Comparable接口,重写compareTo方法,在里面写按照什么进行升序或降序排列
• 2.重写Comparator

3.LinkedHashMap

• 底层数据结构依然是基于哈希表实现的,只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序(保证有序)
• 实际上:原来学习的LinkedHashSet集合的底层原理就是LinkedHashMap

5.集合嵌套

在Map<>的括号中把值定义为一个List集合,然后再下面也定义出这个集合

public class Test {
    public static void main(String[] args) {
        Map<String, List<String>> map = new HashMap<>();
        List<String> cities = new ArrayList<>();
        Collections.addAll(cities,"周口市" ,"新乡市" ,"郑州市", "信阳市");
        map.put("河南省",cities);
        System.out.println(map);

        List<String> city = map.get("河南省");
        for (String s : city) {
            System.out.println(s);
        }

        map.forEach((p,c)->{
            System.out.println(p + "--->" + c);
        });
    }
}

四.Stream

1.什么是Stream?

• 也叫Stream流,是jdk8开始新增的一套API,可以用来操作集合或者数组的数据
• 优势:Stream流大量的结合了Lambda的语法风格来编程,提供了一种更加强大,更加简单的方式操作集合或者数组中的数据,代码更简洁,可读性更好
  
  代码实现

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(s -> s.getKey().contains("巴")).forEach(System.out::println);

        // 4.如何获取数组的Stream流？
        String[] name = {"张翠山", "东方不败", "唐大山", "独孤求败"};
        Stream<String> s1 = Arrays.stream(name);
        Stream<String> s2 = Stream.of(name);
    }
}

2.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.0).sorted().forEach(s -> System.out.println(s));

        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(student -> student.getAge() >= 23 && student.getAge() <= 30)
                .sorted((o1,o2) -> o2.getAge() - o1.getAge())
                .forEach(student -> System.out.println(student));
        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名学生，并输出
        students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
                .skip(students.size() - 2).forEach(System.out::println);
        System.out.println("-----------------------------------------");

        // 需求5：找出身高超过168的学生的名字，要求去除重复的名字，并输出
        students.stream().filter(student -> student.getHeight() > 168).map(Student::getName)
                .distinct().forEach(System.out::println);
        System.out.println("---------------------------------------");

        // distinct去重复，自定义类型的对象（希望内容一样被认为重复，需要重写hashCode，equals）
        students.stream().filter(student -> student.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流:方便\操作集合/数组的手段;集合/数组:才是开发的目的

代码来描述这些方法

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的学生有几人
        System.out.println(students.stream().filter(student -> student.getHeight() > 168).count());
        // 需求2：请找出身高最高的学生对象，并输出
        Student student1 = students.stream().max((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
        System.out.println(student1);

        // 需求3：请找出升高最矮的学生对象，并输出
        Student student2 = students.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
        System.out.println(student2);

        // 需求4：请找出升高超过170的学生对象，并放到一个新集合中去返回
        // 流只能收集一次
        List<Student> list =  students.stream().filter(student -> student.getHeight() > 170).collect(Collectors.toList());
        System.out.println(list);

        // 放到一个Set集合中去
        Set<Student> set =  students.stream().filter(student -> student.getHeight() > 170).collect(Collectors.toSet());
        System.out.println(set);

        // 需求5：请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合返回
        Map<String,Double> map =
                students.stream().filter(student -> student.getHeight() > 170)
                        .distinct()
                        .collect(Collectors.toMap(student -> student.getName(), student -> student.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));
    }
}