如何使用Java8-Stream-流处理集合

关注我，更多精彩文章第一时间推送给你

简介

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

下面通过代码了解下

创建学生类、精英学生类

/**
 * 定义学生类
 */
@Data
@AllArgsConstructor
class Student {
    
    
    private Integer id;
    private String name;
    private Integer age;
    private Double score;
}

/**
 * 定义精英学生类
 */
@Data
class EliteStudent {
    
    
    private String name;
    private Double score;
}

构建两个集合，用于Stream()流处理

@Slf4j
@SpringBootTest
class StreamTest {
    
    

    private List<Student> list;
    private List<List<Student>> listFlat;

    @BeforeEach//注解在非静态方法上
    void init() {
    
    
        list = Arrays.asList(
                new Student(1, "盖伦1", 200, 66.0),
                new Student(2, "赵信", 21, 90.0),
                new Student(3, "乐芙兰1", 21, 90.0),
                new Student(4, "李青", 50, 100d),
                new Student(5, "泰达米尔", 600, 90d)
        );

        listFlat = Arrays.asList(
                Arrays.asList(
                        new Student(1, "盖伦1", 200, 66.0),
                        new Student(2, "赵信", 21, 90.0)
                ),
                Arrays.asList(
                        new Student(3, "乐芙兰1", 21, 90.0),
                        new Student(4, "李青", 50, 100d)
                ),
                Collections.singletonList(
                        new Student(5, "泰达米尔", 600, 90d)
                )
        );
    }
    
    //各种流处理方法---------filter
    //----------------------map
    //--------------------reduce等等
        
}

1.filter

/**
     * filter
     * @DESC 过滤出list中学生名字中包括 "1" 的学生集合，
     *       并使用peek()利用其返回Stream<Student>直接以流的方式实现打印过滤出的学生
     *
     *       peek() 和 ForEach() 的区别：
     *       前者返回Stream<T> 可在流的基础上继续流操作
     *       后者返回void,想要继续流操作需要进行二次流处理
     */
    @Test
    void filterTest() {
    
    
        final List<Student> collect = list.stream().filter(item -> item.getName().contains("1"))
                .peek(System.out::println)
                .collect(Collectors.toList());
        Assertions.assertEquals(2, collect.size());

        /**
         * 获取过滤的第一条数据，如果包含则打印
         */
        list.stream().filter(item -> item.getName().contains("1"))
                .findFirst()
                .ifPresent(System.out::println);
    }

2.map

/**
     * map
     * @DESC 可以将List里面的对象转化成新的对象
     * 1.将学生集合里不小于90分的作为精英学生过滤出来,并打印
     * 2.获取所有学生的 name 集合,并打印
     */
    @Test
    void mapTest() {
    
    
        final List<EliteStudent> collect = list.stream().filter(item -> item.getScore() >= 90)
                .map(student -> {
    
    
                    EliteStudent eliteStudent = new EliteStudent();
                    BeanUtils.copyProperties(student, eliteStudent);
                    return eliteStudent;
                }).peek(System.out::println)
                .collect(Collectors.toList());
        Assertions.assertEquals(3, collect.size());

        final List<String> nameList = list.stream().map(Student::getName)
                .peek(System.out::println)
                .collect(Collectors.toList());
        Assertions.assertEquals(5, nameList.size());

    }

3.flatMap

/**
     * flatMap
     * @DESC 将嵌套列表转换为普通列表，例如 List<List<Student>> 转化为 List<Student>
     * 1.将嵌套列表转化成普通列表，断言转化结果 = list
     * 2.转化后获取列表的 id 集合并打印
     * 3.转化后再提取集合的分数，求平均值，打印平均值
     */
    @Test
    void flatMapTest() {
    
    
        List<Student> collect = listFlat.stream().flatMap(Collection::stream)
                .peek(System.out::println)
                .collect(Collectors.toList());
        Assertions.assertEquals(collect, list);

        List<Integer> idList = listFlat.stream().flatMap(Collection::stream)
                .peek(System.out::println)
                .flatMapToInt(student -> IntStream.of(student.getId()))
                .peek(System.out::println)
                .boxed()
                .collect(Collectors.toList());
        Assertions.assertEquals(idList.size(), 5);

        listFlat.stream().flatMap(Collection::stream)
                .mapToDouble(Student::getScore)
                .average()
                .ifPresent(System.out::println);

    }

4.sorted

/**
     * sorted
     * @DESC 排序
     * 1.先按照分数倒叙排列，如果分数相同按照年龄正序排列，如果年龄相同按照 id 正序排列，打印
     * 2.如果 reversed() 写在最后，则全部按照倒叙排列
     */
    @Test
    void sortedTest() {
    
    
        List<Student> collect = list.stream().sorted(Comparator.comparing(Student::getScore).reversed()
                .thenComparing(Student::getAge)
                .thenComparing(Student::getId))
                .peek(System.out::println)
                .collect(Collectors.toList());
        Assertions.assertEquals("李青", collect.get(0).getName());

        log.info("-------------------------------------------------------------");

        List<Student> collect2 = list.stream().sorted(Comparator.comparing(Student::getScore)
                .thenComparing(Student::getAge)
                .thenComparing(Student::getId).reversed())
                .peek(System.out::println)
                .collect(Collectors.toList());
        Assertions.assertEquals("李青", collect2.get(0).getName());
    }

5.match

/**
     * match
     * @DESC 验证list中的每一项是否匹配我们的条件
     * allMatch 全都匹配
     * anyMatch 任意匹配
     * noneMatch 全不匹配
     *
     * 设置匹配条件为正则表达式 ^[1-9]\\d*$ 正整数
     * 1.验证list的id是否全都匹配条件
     * 2.临时改变list的第一个年龄为 -1 验证是否年龄任意一个匹配条件
     * 3.验证分数是否全不匹配条件
     */
    @Test
    void matchTest() {
    
    
        boolean b = list.stream().allMatch(item -> ReUtil.isMatch("^[1-9]\\d*$", item.getId().toString()));
        log.info("输出list的id是否全部匹配条件,结果：----------[{}]", b);

        list.get(0).setAge(-1);
        list.forEach(System.out::println);
        boolean b1 = list.stream().anyMatch(item -> ReUtil.isMatch("^[1-9]\\d*$", item.getAge().toString()));
        log.info("输出list的年龄是否任意匹配条件,结果：----------[{}]", b1);

        boolean b2 = list.stream().noneMatch(item -> ReUtil.isMatch("^[1-9]\\d*$", item.getScore().toString()));
        log.info("输出list的年龄是否都不匹配条件,结果：----------[{}]", b2);

    }

6.reduce

/**
     * reduce
     * @DESC 合并流元素产生单个值
     * 1.计算list中所有学生年龄的总和，存在则打印
     * 2.计算list中所有学生年龄的总和，存在则打印
     */
    @Test
    void reduceTest() {
    
    
        list.stream().map(Student::getAge)
                .reduce(Integer::sum)
                .ifPresent(System.out::println);

        list.stream().map(Student::getScore)
                .reduce(Double::sum)
                .ifPresent(System.out::println);
    }

7.collertor

/**
     * collector
     * 收集器，主要用于toList() / toSet() / toMap() / joining()连接字符串
     * 1.把list中的id作为key, name作为value转化成Map
     * 2.把学生名字用逗号拼接，并且第一个逗号用星号替换
     */
    @Test
    void collectorTest() {
    
    

        Map<Integer, String> map = list.stream().collect(Collectors.toMap(Student::getId, Student::getName));
        map.forEach((k, v) -> log.info("key = {} , value = {}", k, v));

        String s = list.stream().map(Student::getName)
                .collect(Collectors.joining(","))
                .replaceFirst(",", "*");
        log.info("输出逗号拼接的字符串-->{}", s);

    }

8.summarizingDouble

/**
     * summarizingDouble
     * 1.计算集合中某个元素的 count / sum / avg / min / max
     * 2.第二种写法
     */
    @Test
    void summarizingDoubleTest() {
    
    
        DoubleSummaryStatistics collect = list.stream()
                .collect(Collectors.summarizingDouble(Student::getScore));
        System.out.println(collect);

        DoubleSummaryStatistics doubleSummaryStatistics = list.stream()
                .mapToDouble(Student::getScore)
                .summaryStatistics();
        System.out.println(doubleSummaryStatistics);
    }

9.partitioningBy

/**
     * partitioningBy
     * @DESC 用于分割列表
     * 把学生列表中年龄大于100的放进key为true的Map中
     * 小于等于100的放进key为false的Map中
     */
    @Test
    void partitioningByTest() {
    
    
        Map<Boolean, List<Student>> map = list.stream()
                .collect(Collectors.partitioningBy(e -> e.getAge() > 100));
        log.info("true列表 = {}", map.get(Boolean.TRUE));
        log.info("false列表 = {}", map.get(Boolean.FALSE));
    }

10.groupingBy

/**
     * groupingBy
     * @DESC 分组
     * 1.根据成绩分组
     * 2.获取每个分数的人数
     * 3.根据成绩获取取得每个成绩的学生的总分
     */
    @Test
    void groupingByTest() {
    
    
        Map<Double, List<Student>> map1 = list.stream().collect(Collectors.groupingBy(Student::getScore));
        map1.forEach((k, v) -> System.out.println(k + "\t" + v));

        Map<Double, Long> map2 = list.stream().collect(Collectors.groupingBy(Student::getScore, Collectors.counting()));
        map2.forEach((k,v) -> System.out.println(k + "\t" + v));

        Map<Double, Double> map3 = list.stream()
                .collect(Collectors.groupingBy(Student::getScore, Collectors.summingDouble(Student::getScore)));
        map3.forEach((k, v) -> System.out.println(k + "\t" + v));
    }

11.parallel

/**
     * parallel
     * @DESC 并发
     * 延迟一秒后，并发的打印出学生的名字
     */
    @Test
    void parallel() {
    
    
        list.stream().parallel().forEach(this::print);
    }

    private void print(Student student) {
    
    
        try {
    
    
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        log.info("学生的名字是 ： {}", student.getName());
    }

12.读写文件

/**
     * @DESC 读写文件
     * 先把list中的数据写到student.txt中
     * 再读取出来
     */
    @Test
    void fileTest() throws IOException {
    
    
        PrintWriter printWriter = new PrintWriter(Files.newBufferedWriter(Paths.get("D://student.txt")));
        //list列表写出到文件student.txt中
        list.forEach(printWriter::println);
        printWriter.close();
        //读取文件
        List<String> collect = Files.lines(Paths.get("D://student.txt"))
                .peek(System.out::println)
                .collect(Collectors.toList());
        Assertions.assertEquals(5, collect.size());
    }