Java 1.8 Stream 用例测试

package stream;

import model.Student;
import org.junit.jupiter.api.Test;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 使用Stram流操作集合信息
 * @auther minghao
 * @date 2019.02.11
 */
public class studyStream {



    /**
     *
     */
    @Test
    public void test3() {
        //1.创建实体类准备数据
        List<Student> students = new ArrayList<Student>() {
            {
                add(new Student(20160001, "孔明", 20, 1, "土木工程", "武汉大学"));
                add(new Student(20160002, "伯约", 21, 2, "信息安全", "武汉大学"));
                add(new Student(20162001, "仲谋", 19, 3, "土木工程", "浙江大学"));
                add(new Student(20162001, "仲谋", 25, 3, "土木工程", "浙江大学"));
                add(new Student(20162001, "仲谋", 28, 3, "土木工程", "浙江大学"));
                add(new Student(20160003, "玄德", 22, 3, "经济管理", "武汉大学"));
                add(new Student(20160004, "云长", 21, 2, "信息安全", "武汉大学"));
                add(new Student(20161001, "翼德", 21, 2, "机械与自动化", "华中科技大学"));
                add(new Student(20161002, "元直", 23, 4, "土木工程", "华中科技大学"));
                add(new Student(20161003, "奉孝", 23, 4, "计算机科学", "华中科技大学"));
                add(new Student(20162001, "仲谋", 22, 3, "土木工程", "浙江大学"));
                add(new Student(20162002, "鲁肃", 23, 4, "计算机科学", "浙江大学"));
                add(new Student(20163001, "丁奉", 24, 5, "土木工程", "南京大学"));
            }
        };


        /**
         * 方式一：前面例子中使用的方式
         * 获取计算机科学专业学生的年龄总和
         */
        int totalAge = students.stream().filter(student -> "计算机科学".equals(student.getMajor())).mapToInt(Student::getAge).sum();


        /**
         * 方式二：归约操作 reduce
         * 获取计算机科学专业学生的年龄总和
         */
        int totalAge2 = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
                                 .mapToInt(Student::getAge).reduce(0,(a,b) -> a+b);

        /**
         * 方式三：归约操作（进一步简化） reduce
         * 获取计算机科学专业学生的年龄总和
         */
        int reduceAges = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
                .mapToInt(Student::getAge).reduce(0,Integer::sum);
        /**
         * 方式四：归约操作（进一步简化） reduce
         *      采用无初始值的重载版本，需要注意返回Optional
         * 获取计算机科学专业学生的年龄总和
         */
        Optional optAges = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
                .map(Student::getAge).reduce(Integer::sum);


        /**
         * 求学生的总数
         */
        long count = students.stream().collect(Collectors.counting());
        //进一步简化
        long count1 = students.stream().count();


        /**
         * 求年龄的最大值和最小值
         */

        //求最大年龄
        Optional<Student> collect = students.stream().collect(Collectors.maxBy((s1, s2) -> s1.getAge() - s2.getAge()));
        //进一步简化 求最大年龄
        Optional<Student> collect1 = students.stream().collect(Collectors.maxBy(Comparator.comparing(Student::getAge)));
        //求最小年龄
        Optional<Student> collect2 = students.stream().collect(Collectors.minBy(Comparator.comparing(Student::getAge)));


        /**
         * 求年龄总和
         */
        Integer sunAges = students.stream().collect(Collectors.summingInt(Student::getAge));


        /**
         * 求年龄的平均值
         */
        Double avgAge = students.stream().collect(Collectors.averagingInt(Student::getAge));

        /**
         * 一次性得到元素(年龄)的个数、总和、均值、最大值、最小值
         */
        IntSummaryStatistics collect3 = students.stream().collect(Collectors.summarizingInt(Student::getAge));


        /**
         * 字符串拼接,拼接所有对象的名字
         */
        String join = students.stream().map(Student::getName).collect(Collectors.joining());
        String join2 = students.stream().map(Student::getName).collect(Collectors.joining(","));


        /**
         * 按照学校进行分组(一级分组)
         */
        Map<String, List<Student>> groupbySchool = students.stream().collect(Collectors.groupingBy(Student::getSchool));

        /**
         * 按照学校进行分组，再按照专业分组(多级分组)
         */
        Map<String,Map<String,List<Student>>> groupbySchoolAndMajor = students.stream().collect(
                        Collectors.groupingBy(Student::getSchool,    //一级分组
                                      Collectors.groupingBy(Student::getMajor)  //二级分组（二级套在一级里面）
                ));


        /**
         * 传递一个Collector.counting，用以统计每个组的个数：
         * 统计根据学校分组，每组的数量
         */
        Map<String, Long> counting = students.stream().collect(Collectors.groupingBy(Student::getSchool, Collectors.counting()));


        /**
         * 使用分区Collectors.partitioningBy()
         * 将学生分为武大学生和非武大学生
         */
        Map<Boolean, List<Student>> isWhuSchool = students.stream().collect(Collectors.partitioningBy(student -> "武汉大学".equals(student.getSchool())));


        System.out.println();
    }


    /**
     *
     */
    @Test
    public void test2(){
        //1.创建实体类准备数据
        List<Student> students = new ArrayList<Student>() {
            {
                add(new Student(20160001, "孔明", 20, 1, "土木工程", "武汉大学"));
                add(new Student(20160002, "伯约", 21, 2, "信息安全", "武汉大学"));
                add(new Student(20162001, "仲谋", 19, 3, "土木工程", "浙江大学"));
                add(new Student(20162001, "仲谋", 25, 3, "土木工程", "浙江大学"));
                add(new Student(20162001, "仲谋", 28, 3, "土木工程", "浙江大学"));
                add(new Student(20160003, "玄德", 22, 3, "经济管理", "武汉大学"));
                add(new Student(20160004, "云长", 21, 2, "信息安全", "武汉大学"));
                add(new Student(20161001, "翼德", 21, 2, "机械与自动化", "华中科技大学"));
                add(new Student(20161002, "元直", 23, 4, "土木工程", "华中科技大学"));
                add(new Student(20161003, "奉孝", 23, 4, "计算机科学", "华中科技大学"));
                add(new Student(20162001, "仲谋", 22, 3, "土木工程", "浙江大学"));
                add(new Student(20162002, "鲁肃", 23, 4, "计算机科学", "浙江大学"));
                add(new Student(20163001, "丁奉", 24, 5, "土木工程", "南京大学"));
            }
        };

        /**
         * 2.使用stream流的filter过滤，通过lambda表达式从集合students中筛选出所有武汉大学的学生
         *
         * stream()：将students集合转为stream流
         * filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
         * collect(): 终端操作
         * Conllect.toList()： 将结果封装成为一个list集合
         */

        List<Student> whustudents = students.stream().filter(student -> "武汉大学".equals(student.getSchool())).collect(Collectors.toList());



        /**
         * 3.使用stream流的filter + limit，通过lambda表达式从集合students中获取2个专业为土木工程专业的学生
         *
         * stream()：将students集合转为stream流
         * filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
         * limit()：限制返回的数量
         * collect(): 终端操作
         * Conllect.toList()： 将结果封装成为一个list集合
         *
         */
        List<Student> limitStudents = students.stream().filter(a -> "土木工程".equals(a.getMajor())).limit(2).collect(Collectors.toList());


        /**
         * 4.使用stream流的filter + limit + sorted，
         * 通过lambda表达式从集合students中获取2个专业为土木工程专业的学生,
         * 并按年龄从小到大排序，筛选出年龄最小的两个学生
         *
         * stream()：将students集合转为stream流
         * filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
         * limit()：限制返回的数量
         * sorted()：对两个值进行排序
         * collect(): 终端操作
         * Conllect.toList()： 将结果封装成为一个list集合
         *
         */
        List<Student> sortedStudents = students.stream().filter(student -> "土木工程".equals(student.getMajor()))
                .sorted((s1,s2) -> s1.getAge() - s2.getAge()).limit(2).collect(Collectors.toList());


        /**
         * 5.使用stream流 filter + skip 找出排序在2之后的土木工程专业的学生
         *
         * stream()：将students集合转为stream流
         * filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
         * skip()：对筛选出来的结果，排除前面N个数量
         * collect(): 终端操作
         * Conllect.toList()： 将结果封装成为一个list集合
         */
        List<Student> skipStudents = students.stream().filter(student -> "土木工程".equals(student.getMajor()))
                                             .skip(2).collect(Collectors.toList());



        /**
         * 1.使用stream流 filter + map 通过map将学生实体映射成为学生姓名字符串
         * 获取专业为计算机科学的所有学生姓名
         *
         * stream()：将students集合转为stream流
         * filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
         * .map(Student :: getName)：获取当前实体类的姓名，返回给list集合
         * collect(): 终端操作
         * Conllect.toList()： 将结果封装成为一个list集合
         */
        List<String> names = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
                                     .map(Student :: getName).collect(Collectors.toList());

        /**
         * 2.使用stream流 filter + map 通过map将学生实体映射成为学生年龄
         * 获取专业为计算机科学的所有学生年龄
         *
         * stream()：将students集合转为stream流
         * filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
         * .map(Student :: getAge)：获取当前实体类的年龄，返回给list集合
         * collect(): 终端操作
         * Conllect.toList()： 将结果封装成为一个list集合
         */
        List<Integer> ages = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
                .map(Student :: getAge).collect(Collectors.toList());

        /**
         * 3.使用stream流 filter + maptoInt 通过map将学生实体映射成为学生年龄 的总和
         * 获取专业为计算机科学的所有学生年龄 的总和（年龄相加）
         *
         * stream()：将students集合转为stream流
         * filter(): 中间操作 使用lambda表达式进行判断，返回boolean类型
         * .map(Student :: getAge)：获取当前实体类的年龄，返回给list集合
         * sum(): 返回年龄的总和（年龄相加）
         */
        int agesSum  = students.stream().filter(student -> "计算机科学".equals(student.getMajor()))
                .mapToInt(Student :: getAge).sum();



        String[] strs = {"java8", "is", "easy", "to", "use"};
        /**
         * 将数组strs 中的每个元素使用split 拆分成为数组
         * 返回list<String[]>的集合数组
         * 注：distinct只有对于一个包含多个字符的流进行操作才能达到我们的目的
         * 因此，下面两行代码效果一致
         */
        List<String[]> distinctStrs = Arrays.stream(strs).map(str -> str.split("")).distinct().collect(Collectors.toList());
        List<String[]> Strs = Arrays.stream(strs).map(str -> str.split("")).collect(Collectors.toList());


        /**
         * 将数组strs 中的每个元素使用split 拆分成为数组
         * flatMap()：将数组的多个元素转换成为一个元素进行输出
         *
         * flatMap与map的区别在于 flatMap是将一个流中的每个值都转成一个个流，然后再将这些流扁平化成为一个流 。
         */
        List<String> flatMapStrs = Arrays.stream(strs).map(str -> str.split(""))    //得到List<String[]>
                                            .flatMap(Arrays::stream).collect(Collectors.toList()); //将List<String[]> 转化为List<String>

        String a = flatMapStrs.toString();


        /**
         * allMatch()：判断当前集合中所有人的年龄是否大于等于18岁
         * true 全部大于/等于
         * false 相反
         */
        boolean isAdult = students.stream().allMatch(student -> student.getAge() >= 18);

        /**
         * anyMatch()：判断当前集合中是否存在个别人的年龄是否大于等于18岁
         * true 一个或多个存在
         * false 一个也不存在
         */
        boolean hasWhu = students.stream().anyMatch(student -> student.getAge() >= 18);


        /**
         * noneMatch()：判断当前集合是否不存在filter指定的元素
         * true 不存在
         * false 存在
         */
        boolean noneCs = students.stream().noneMatch(student -> "计算机科学".equals(student.getMajor()));


        /**
         * findFirst()：返回返回满足条件的第一个元素
         */
        Optional<Student> optstu = students.stream().filter(student -> "土木工程".equals(student.getMajor())).findFirst();


        /**
         * findAny()：返回返回满足条件的任意一个元素
         */
        Optional<Student> anyoptstu = students.stream().filter(student -> "土木工程".equals(student.getMajor())).findAny();






        System.out.println();

    }



    /**
     * 初步使用stream流完集合遍历
     */
    @Test
    public void test(){
        //1.准备数据
        List<Integer> nums = new ArrayList<>();
        for (int i = 1; i <= 20;i++){
            nums.add(i);
        }
        for (int i = 10; i <= 20;i++){
            nums.add(i);
        }


        //2.使用foreach筛选偶数
        List<Integer> evens = new ArrayList<>();
        for (Integer num: nums) {
            if (num % 2 == 0)
                evens.add(num);
        }

        /**
         * 3.1：使用stream流完成筛选偶数 返回list集合 filter() +collect()
         *
         * 一个流的处理分为三部分：转换成流 ——> 中间操作(自定义) ——> 终端操作
         * 例如：
         * stream()：将集合转换成流
         * filter()：指定我们自定义的筛选处理/自定义其他处理
         * collect()：对结果进行封装处理
         * Collectors.toList()：指定其筛选流结果，封装成一个List集合进行返回
         */
        List<Integer> StreamEvens = nums.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
        System.out.println();


        /**
         * 3.2：使用stream流完成筛选偶数，并去掉重复 返回list集合  filter() + distinct() + collect()
         *
         * stream()：将集合转换成流
         * filter()：指定我们自定义的筛选处理/自定义其他处理
         * collect()：对结果进行封装处理
         * distinct()：去掉重复
         * Collectors.toList()：指定其筛选流结果，封装成一个List集合进行返回
         */
        List<Integer> distinctEvens = nums.stream().filter(num -> num % 2 == 0).distinct().collect(Collectors.toList());
        System.out.println();

    }


}