JDK8新特性-Stream

一，认识Stream:

。也叫Stream流，是jdk8开始新增的一套API，可以用于操作集合或者数组的数据

是一个接口，不能直接创建对象

1，优势：

Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或数组中的数据，代码更简洁，可读性更好

public class StreamTest1 {
    public static void main(String[] args) {
        List names = new ArrayList<>();
        Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
        System.out.println(names);
        // names = [张三丰, 张无忌, 周芷若, 赵敏, 张强]
        //          name

        // 目标：：：：：找出姓张，且是3个字的名字，存入到一个新集合中去。
        //原来的方式：
        List list = new ArrayList<>();
        for (String name : names) {            //遍历：names.for回车。增强for循环
            if(name.startsWith("张") && name.length() == 3){
                list.add(name);
            }
        }
        System.out.println(list); //[张三丰，张无忌]

        // 使用Stream流来解决：
        List list2 = names.stream().filter(s -> s.startsWith("张"))
                .filter(a -> a.length()==3).collect(Collectors.toList());
        System.out.println(list2);//[张三丰，张无忌]
    }
}
//         一:name.stream().filter(写Lambda表达式：s ->s.startsWith("张"))------.collect(Collectors.toList());
//                     s是一个变量，可以随便取，代表集合中的每一个数据
//                      s.startsWith("张")是条件，每一个数据必须以张开头

 2，Stream流的使用步骤：

二，Stream的常用方法：

1,如何获取Stream流？

        // 1、如何获取List集合的Stream流？
        List names = new ArrayList<>();
        Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
        Stream stream = names.stream();//调names.stream()方法

        // 2、如何获取Set集合的Stream流？
        Set set = new HashSet<>();
        Collections.addAll(set, "刘德华","张曼玉","蜘蛛精","马德","德玛西亚");
        Stream stream1 = set.stream();
        stream1.filter(s -> s.contains("德")).forEach(s -> System.out.println(s));
//                                        调forEach方法进行遍历
        

        // 3、如何获取Map集合的Stream流？
        Map map = new HashMap<>();
        map.put("古力娜扎", 172.3);
        map.put("迪丽热巴", 168.3);
        map.put("马尔扎哈", 166.3);
        map.put("卡尔扎巴", 168.3);

        //Map集合不属于collection,不能调其方法
        Set keys = map.keySet();//法一：调map.keySet()
        Stream ks = keys.stream();//keys流获得的是键的流，只能处理键数据

        Collection values = map.values();//map.values()得到值的集合
        Stream vs = values.stream();//得到值的流

        Set> entries = map.entrySet();//法二：map.entrySet()方法，把Map集合转化为Set集合
        Stream> kvs = entries.stream();//entries.stream()方法
        kvs.filter(e -> e.getKey().contains("巴"))
                .forEach(e -> System.out.println(e.getKey()+ "---->" + e.getValue()));

        String[] names2 = {"张翠山", "东方不败", "唐大山", "独孤求败"};
        Stream s1 = Arrays.stream(names2);//法一
        
        Stream s2 = Stream.of(names2);//法二
   

2，Stream流常见的中间方法：（重要！！！！）

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

public class StreamTest3 {
    public static void main(String[] args) {
        List 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(s -> System.out.println(s));
//                                       sorted方法，升序
        
        List 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(s -> System.out.println(s));

        // 需求3：取出身高最高的前3名学生，并输出。
        //                         身高是double类型，不能直接做差。Double.compare
        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)
        //                                                   map方法：map(s -> s.getName()),最后留下的只有对象的名字
        //                                                       方法引用简化 
               .distinct().forEach(System.out::println);
        //      distinct是去重复的方法

        // distinct去重复，自定义类型的对象（希望内容一样就认为重复，必须在学生类中重写hashCode和equals）
        students.stream().filter(s -> s.getHeight() > 168)
                .distinct().forEach(System.out::println);

        //contact方法：将2个流合并成一个流
        Stream st1 = Stream.of("张三", "李四");
        Stream st2 = Stream.of("张三2", "李四2", "王五");
        Stream allSt = Stream.concat(st1, st2);
        allSt.forEach(System.out::println);//输出5个
    }
}

3，Stream流常见的终结方法：

        List 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的学生有几人。
        //count方法：返回的数据是long类型的
        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();
        //                                    比较规则                                                get把它取出来
        System.out.println(s);

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

收集Stream流：

        // 需求4：请找出身高超过170的学生对象，并放到一个新集合中去返回。
        // 注意：流只能收集一次。！！！！！！
        List students1 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toList());
        // 用list集合接                                                               调collect方法把收集到的放到list集合中去
        System.out.println(students1);

        Set students2 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toSet());
        //                                                                                         放到Set集合中
        System.out.println(students2);

        // 需求5：请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合返回。
        Map map =
                students.stream().filter(a -> a.getHeight() > 170)
                        .distinct().collect(Collectors.toMap(a -> a.getName(), a -> a.getHeight()));
        //            distinct方法把重复的去掉
        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]);
        //                                                               调toArry（）方法，把数据收集到一个数组中去
        System.out.println(Arrays.toString(arr));