Java 8 Stream

Java 8 API 增加了一个新的抽象称为流 Stream，可以让你以一种声明的方式处理数据。Stream 使用一种类似 SQL 语句从数据库查询数据的方式来提供一种对 Java 集合运算和表达的高阶抽象。这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选、排序、聚合等。如果你之前有 RxJava 的使用经历，应该不会对流的操作感到陌生，并且 Stream 要比 RxJava 更容易上手。

元素流在管道中经过中间操作的处理，最后由最终操作得到前面处理的结果。下图展示了元素流经过筛选、排序、映射操作后，最终被转换成聚合元素的过程。后续我们将会对 Stream 的各种操作符进行展示。

此处输入图片的描述

1. 生成流

1.1 随机数

1
2
3
4
/*** 随机数方式生成流 ***/

List<Integer> collect = new Random().ints(5, 1, 100).boxed().collect(Collectors.toList());
System.out.println("结果为 : " + collect);
1
2
3
/***** 数据输出结果 *****/

结果为 : [24, 51, 52, 27, 29]

1.2 正则匹配

1
2
3
4
5
/**** 正则方式生成流 ****/

String source = "张三，李四。王五？赵六：孙七";
List<String> collect = Pattern.compile("[。，？：]+").splitAsStream(source).collect(Collectors.toList());
System.out.println("结果为 : " + collect);
1
2
3
/***** 数据输出结果 *****/

结果为 : [张三, 李四, 王五, 赵六, 孙七]

2. 数据操作

2.1 分组

2.1.1 数据准备

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/***** 实体类 User  *****/

public class User {

    private String grade;   // 等级

    private String name;    // 姓名

    private int age;        // 年龄

    private int score;      // 积分
    
    public int coin;        // 金币

}
1
2
3
4
5
6
7
8
/**** 新建 User 实例 ****/

User user1 = new User("1", "杨星辰", 20, 100, 10);
User user2 = new User("2", "李明轩", 19, 104, 15);
User user3 = new User("1", "张若扬", 22, 200, 11);
User user4 = new User("3", "方君彦", 24, 120, 32);
User user5 = new User("2", "周诚文", 20, 110, 50);
User user6 = new User("4", "杨天厉", 21, 108, 10);
1
2
3
/**** 获取 User 集合 ****/

List<User> users = Stream.of(user1, user2, user3, user4, user5, user6).collect(Collectors.toList());

2.1.2 按等级分组

1
2
3
4
5
6
7
8
9
10
11
12
/***** 原始代码分组 *****/

Map<String, List<User>> data = users.stream().collect(Collectors.groupingBy(new Function<User, String>() {
    @Override
    public String apply(User user) {
        return user.getGrade();
    }
}));

/***** Lambda表达式 *****/

Map<String, List<User>> data = users.stream().collect(Collectors.groupingBy(User::getGrade));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/***** 数据输出结果 *****/

{
  "1":[
      {"age":20,"grade":"1","name":"杨星辰","score":100},
      {"age":22,"grade":"1","name":"张若扬","score":200}
    ],
  "2":[
      {"age":19,"grade":"2","name":"李明轩","score":104},
      {"age":20,"grade":"2","name":"周诚文","score":110}
    ],
  "3":[
      {"age":24,"grade":"3","name":"方君彦","score":120}
    ],
  "4":[
      {"age":21,"grade":"4","name":"杨天厉","score":108}
    ]
}

2.1.3 按等级分组获取用户名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/***** 原始代码分组 *****/

Map<String, List<String>> data = users.stream().collect(Collectors.groupingBy(new Function<User, String>() {
    @Override
    public String apply(User user) {
        return user.getGrade();
    }
}, Collectors.mapping(new Function<User, String>() {
    @Override
    public String apply(User user) {
        return user.getName();
    }
}, Collectors.toList())));

/***** Lambda表达式 *****/

Map<String, List<String>> data = users.stream().collect(Collectors.groupingBy(User::getGrade, Collectors.mapping(User::getName, Collectors.toList())));
1
2
3
4
5
6
7
8
/***** 数据输出结果 *****/

{
  "1":["杨星辰","张若扬"],
  "2":["李明轩","周诚文"],
  "3":["方君彦"],
  "4":["杨天厉"]
}

2.1.4 按等级分组统计人数

1
2
3
4
5
6
7
8
9
10
11
12
/***** 原始代码分组 *****/

Map<String, Long> data = users.stream().collect(Collectors.groupingBy(new Function<User, String>() {
    @Override
    public String apply(User user) {
        return user.getGrade();
    }
}, Collectors.counting()));

/***** Lambda表达式 *****/

Map<String, Long> data = users.stream().collect(Collectors.groupingBy(User::getGrade, Collectors.counting()));
1
2
3
/***** 数据输出结果 *****/

{"1":2,"2":2,"3":1,"4":1}

2.1.5 按等级统计平均积分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/***** 原始代码分组 *****/

Map<String, Double> data = users.stream().collect(Collectors.groupingBy(new Function<User, String>() {
    @Override
    public String apply(User user) {
        return user.getGrade();
    }
}, Collectors.averagingDouble(new ToDoubleFunction<User>() {
    @Override
    public double applyAsDouble(User user) {
        return user.getScore();
    }
})));

/***** Lambda表达式 *****/

Map<String, Double> data = users.stream().collect(Collectors.groupingBy(User::getGrade, Collectors.averagingDouble(User::getScore)));
1
2
3
/***** 数据输出结果 *****/

{"1":150.0,"2":107.0,"3":120.0,"4":108.0}

2.1.6 按等级分组统计用户资产

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/***** 原始代码分组 *****/

Map<String, Map<String, Integer>> data = users.stream().collect(Collectors.groupingBy(new Function<User, String>() {
    @Override
    public String apply(User user) {
        return user.getGrade();
    }
}, Collectors.toMap(new Function<User, String>() {
    @Override
    public String apply(User user) {
        return user.getName();
    }
}, new Function<User, Integer>() {
    @Override
    public Integer apply(User user) {
        return user.getScore() + user.getCoin();
    }
})));

/***** Lambda表达式 *****/

Map<String, Map<String, Integer>> data = users.stream().collect(Collectors.groupingBy(User::getGrade, Collectors.toMap(User::getName, user -> user.getScore() + user.getCoin())));
1
2
3
4
5
6
7
8
/***** 数据输出结果 *****/

{
  "1":{"张若扬":211,"杨星辰":110},
  "2":{"李明轩":119,"周诚文":160},
  "3":{"方君彦":152},
  "4":{"杨天厉":118}
}

2.2 统计

一些统计结果的收集器也非常有用，它们主要用于 int、double、long 等基本类型，可以用来产生类似如下的统计结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/***** 原始代码统计 *****/

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

IntSummaryStatistics stats = numbers.stream().mapToInt(new ToIntFunction<Integer>() {
    @Override
    public int applyAsInt(Integer integer) {
        return integer;
    }
}).summaryStatistics();

/***** Lambda表达式 *****/

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

IntSummaryStatistics stats = numbers.stream().mapToInt(integer -> integer).summaryStatistics();

System.out.println("最大数 : " + stats.getMax());
System.out.println("最小数 : " + stats.getMin());
System.out.println("数求和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());
1
2
3
4
5
6
/***** 数据输出结果 *****/

最大数 : 7
最小数 : 2
数求和 : 25
平均数 : 3.5714285714285716

2.3 并行流

在 Java 8 中, 集合接口有两个方法来生成流：stream() 和 parallelStream()。他们的区别在于，stream 是顺序流，由主线程按顺序对流执行操作，而 parallelStream 是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。如果流中的数据量足够大，并行流可以加快处速度。例如筛选集合中的奇数，两者的处理不同之处：

方法名 中文概念 描述
stream() 顺序流 为集合创建串行流
parallelStream() 并行流 为集合创建并行流

此处输入图片的描述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/***** parallelStream() 直接创建并行流 *****/

List<Integer> numbers = Arrays.asList(10, 2, 3, 8, 9, 6, 1, 4, 11, 7, 8, 3);

List<Integer> collect = numbers.parallelStream().filter(integer -> integer % 2 == 1).collect(Collectors.toList());


/***** parallel() 将顺序流转换成并行流 *****/

List<Integer> numbers = Arrays.asList(10, 2, 3, 8, 9, 6, 1, 4, 11, 7, 8, 3);

List<Integer> collect = numbers.stream().parallel().filter(integer -> integer % 2 == 1).collect(Collectors.toList());

System.out.println("结果为 : " + collect.toString());
1
2
3
/***** 数据输出结果 *****/

结果为 : [3, 9, 1, 11, 7, 3]
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

慢慢的<br>慢慢的<br>去改变世界