你还在用for循环遍历list吗？

别幼稚了坏蛋-X

已于 2023-10-11 17:39:53 修改

阅读量334

点赞数

分类专栏： Java 文章标签： list java 数据结构

于 2022-09-09 11:25:50 首次发布

本文链接：https://blog.csdn.net/qq_20961933/article/details/126778375

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

你还在用for循环遍历list吗？

Java 8 Stream
什么是 Stream？
生成流
DAO代码
方法
Stream 完整实例代码
- 完整代码
- 输出结果

Java 8 Stream

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

对比起for循环操作list，最大的弊端就是代码太长太乱了，如果涉及3-4张表的操作，也就是涉及多个DAO操作，那个括号简直就是俄罗斯套娃，写到最后真的自己都不知道在写什么。

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

什么是 Stream？

Stream（流）是一个来自数据源的元素队列并支持聚合操作

元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
数据源 流的来源。可以是集合，数组，I/O channel，产生器generator 等。
聚合操作 类似SQL语句一样的操作，比如filter, map, reduce, find, match, sorted等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

Pipelining: 中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式风格（fluent style）。这样做可以对操作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。
内部迭代：以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代，这叫做外部迭代。 Stream提供了内部迭代的方式，通过访问者模式(Visitor)实现。

生成流

在 Java 8 中, 集合接口有两个方法来生成流：

stream() − 为集合创建串行流。
parallelStream() − 为集合创建并行流。

DAO代码

public class UserDao {

    private String name;

    private Double score;

    public UserDao(String name, Double score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "UserPo{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

以下操作均以UserDao进行讲解

方法

filter

filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：

count = userDaoList.stream().filter(p -> null != p.getScore()).count();
System.out.println("参加考试的学生人数：" + count);

map

map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 将集合映射为另一个集合：

List<Double> scoreList = userDaoList.stream().map(p -> p.getScore()).collect(Collectors.toList());
System.out.println("所有学生的成绩集合：" + scoreList);

普通用法

new一个空的List集合

List<String> nameList = new ArrayList<>();

将学生姓名集合串成字符串，用逗号分割（有两种方式实现）

String nameStrings = nameList.stream().map(p -> String.valueOf(p.trim())).collect(Collectors.joining(","));
或
String nameString = nameList.stream().map(String::valueOf).collect(Collectors.joining(","));

Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：

// 按成绩进行归集
System.out.println("按学生成绩归集：");
Map<Double, List<UserDao>> groupBySorceMap = userDaoList.stream().filter(p -> null != p.getScore()).collect(Collectors.groupingBy(UserDao::getScore));
for (Map.Entry<Double, List<UserDao>> entry : groupBySorceMap.entrySet()) {
    System.out.println("成绩：" + entry.getKey() + "人数：" + entry.getValue().size());
}

// 返回list
filterList = userDaoList.stream().filter(p -> null != p.getScore()).collect(Collectors.toList());

//返回String ，用逗号分割
String nameString = userDaoList.stream().map(p -> p.getName()).collect(Collectors.joining(","));

sorted

sorted 方法用于对流进行排序，可以根据指定的字段进行排序

filterList = userDaoList.stream().filter(p -> null != p.getScore()).sorted(Comparator.comparing(UserDao::getScore).reversed()).collect(Collectors.toList());
System.out.println("所有学生的成绩集合，逆序排序：");
filterList.stream().forEach(System.out::println);

forEach

Stream 提供了新的方法 ‘forEach’ 来迭代流中的每个数据

// forEach
filterList.stream().forEach(p -> p.setScore(p.getScore() + 10));
System.out.println("及格的人数太少，给每个人加10分");

statistics

statistics：统计，可以统计中位数，平均值，最大、最小值，它们主要用于int、double、long等基本类型上

DoubleSummaryStatistics statistics = filterList.stream().mapToDouble(p -> p.getScore()).summaryStatistics();
System.out.println("列表中最大的数：" + statistics.getMax());
System.out.println("列表中最小的数：" + statistics.getMin());
System.out.println("所有数之和：" + statistics.getSum());
System.out.println("平均数：" + statistics.getAverage());

parallelStream并行程序

parallelStream 是流并行处理程序的代替方法。并行流，可以利用多线程进行流的操作，提升效率。但是其不具备线程传播性，因此使用时需要充分评估是否需要用并行流操作

count = userDaoList.parallelStream().filter(p -> null != p.getScore()).count();
System.out.println("并行流处理参加考试的学生人数：" + count);

limit

limit 方法用于获取指定数量的流

filterList = userDaoList.stream().limit(3).collect(Collectors.toList());
System.out.println("所有学生集合中前三位学生：");
filterList.stream().forEach(System.out::println);

Stream 完整实例代码

完整代码

public class UserDao {

    private String name;

    private Double score;

    public UserDao(String name, Double score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "UserPo{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

public class StreamTest {

    public static void main(String[] args) {
        // write your code here
        //System.out.print("Hello World");
        List<UserDao> userDaoList = new ArrayList<>();
        userDaoList.add(new UserDao("张三", 40.d));
        userDaoList.add(new UserDao("李四", 50.d));
        userDaoList.add(new UserDao("王五", 60.d));
        userDaoList.add(new UserDao("赵六", 60.d));
        userDaoList.add(new UserDao("周七", null));
        userDaoList.add(new UserDao("钱八", 90.d));
        userDaoList.add(new UserDao("郑九", 80.d));

        long count = 0;
        List<UserDao> filterList = null;

        // filter 过滤器的适应
        // 筛选出成绩不为空的学生人数
        count = userDaoList.stream().filter(p -> null != p.getScore()).count();
        System.out.println("参加考试的学生人数：" + count);
        System.out.println("");

        // collect
        // 删选出成绩不为空的学生集合
        filterList = userDaoList.stream().filter(p -> null != p.getScore()).collect(Collectors.toList());
        System.out.println("参加考试的学生信息：");
        filterList.stream().forEach(System.out::println);
        System.out.println("");

        // map 将集合映射为另一个集合
        List<Double> scoreList = userDaoList.stream().map(p -> p.getScore()).collect(Collectors.toList());
        System.out.println("所有学生的成绩集合：" + scoreList);
        System.out.println("");

        // 将学生姓名集合串成字符串，用逗号分割
        String nameString = userDaoList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
        System.out.println("所有学生的姓名字符串：" + nameString);
        System.out.println("");

        // sorted排序，逆序排序，正序则不需要加.reversed()
        filterList = userDaoList.stream().filter(p -> null != p.getScore()).sorted(Comparator.comparing(UserDao::getScore).reversed()).collect(Collectors.toList());
        System.out.println("所有学生的成绩集合，逆序排序：");
        filterList.stream().forEach(System.out::println);
        System.out.println("");

        System.out.println("按学生成绩归集：");
        Map<Double, List<UserDao>> groupBySorceMap = userDaoList.stream().filter(p -> null != p.getScore()).collect(Collectors.groupingBy(UserDao::getScore));
        for (Map.Entry<Double, List<UserDao>> entry : groupBySorceMap.entrySet()) {
            System.out.println("成绩：" + entry.getKey() + "人数：" + entry.getValue().size());
        }
        System.out.println("");
        // forEach
        filterList.stream().forEach(p -> p.setScore(p.getScore() + 10));
        System.out.println("及格的人数太少，给每个人加10分");
        filterList.stream().forEach(System.out::println);
        System.out.println("");

        // count
        count = filterList.stream().filter(p -> p.getScore() >= 60).count();
        System.out.println("最后及格人数：" + count);
        System.out.println("");

        DoubleSummaryStatistics statistics = filterList.stream().mapToDouble(p -> p.getScore()).summaryStatistics();
        System.out.println("列表中最大的数：" + statistics.getMax());
        System.out.println("列表中最小的数：" + statistics.getMin());
        System.out.println("所有数之和：" + statistics.getSum());
        System.out.println("平均数：" + statistics.getAverage());
        System.out.println("");

        // 并行流 使用
        count = userDaoList.parallelStream().filter(p -> null != p.getScore()).count();
        System.out.println("并行流处理参加考试的学生人数：" + count);
        System.out.println("");

        // limit
        filterList = userDaoList.stream().limit(3).collect(Collectors.toList());
        System.out.println("所有学生集合中前三位学生：");
        filterList.stream().forEach(System.out::println);
        System.out.println("");
    }
}

输出结果

参加考试的学生人数：6

参加考试的学生信息：
UserPo{name='张三', score=40.0}
UserPo{name='李四', score=50.0}
UserPo{name='王五', score=60.0}
UserPo{name='赵六', score=60.0}
UserPo{name='钱八', score=90.0}
UserPo{name='郑九', score=80.0}

所有学生的成绩集合：[40.0, 50.0, 60.0, 60.0, null, 90.0, 80.0]

所有学生的姓名字符串：张三,李四,王五,赵六,周七,钱八,郑九

所有学生的成绩集合，逆序排序：
UserPo{name='钱八', score=90.0}
UserPo{name='郑九', score=80.0}
UserPo{name='王五', score=60.0}
UserPo{name='赵六', score=60.0}
UserPo{name='李四', score=50.0}
UserPo{name='张三', score=40.0}

按学生成绩归集：
成绩：80.0人数：1
成绩：40.0人数：1
成绩：90.0人数：1
成绩：50.0人数：1
成绩：60.0人数：2

及格的人数太少，给每个人加10分
UserPo{name='钱八', score=100.0}
UserPo{name='郑九', score=90.0}
UserPo{name='王五', score=70.0}
UserPo{name='赵六', score=70.0}
UserPo{name='李四', score=60.0}
UserPo{name='张三', score=50.0}

最后及格人数：5

列表中最大的数：100.0
列表中最小的数：50.0
所有数之和：440.0
平均数：73.33333333333333

并行流处理参加考试的学生人数：6

所有学生集合中前三位学生：
UserPo{name='张三', score=50.0}
UserPo{name='李四', score=60.0}
UserPo{name='王五', score=70.0}