Java8 Stream流

本文主要是介绍Java8 Stream流，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

- Stream 的三个操作步骤
- 创建Stream的几种方式
- 中间操作
- - - filter：排除
    - limit：截断
    - skip(n)：跳过元素
    - distinct：去重
    - map：映射
    - sorted：排序
- 终止操作
- - - allMatch：检查是否匹配所有元素
    - anyMatch：检查是否至少匹配一个元素
    - noneMatch：检查是否没有匹配所有元素
    - findFirst：返回第一个元素
    - findAny：返回当前流中的任意元素
    - count：返回流中元素总个数
    - max：返回流中最大值
    - min：返回流中最大值
- reduce：归约
- collect：收集
- - - 汇总
    - 计算
    - 分组
    - 多级分组
    - 分区
    - 字符串连接

文中有使用到Java8的Lambda表达式，若未学习，可点击下方链接学习Lambda表达式
链接: https://blog.csdn.net/qq_41175917/article/details/118785333.

Stream 的三个操作步骤

1、创建 Stream
2、中间操作
3、终止操作（终端操作）

创建Stream的几种方式

1、通过 Collection 系列集合提供的 stream() 或 parallelStream()

	List<String> list = new ArrayList<>();
    Stream<String> stream = list.stream();

2、通过 Arrays 中的静态方法 stream() 获取数组流

    String[] strArr = new String[10];
    Stream<String> stream = Arrays.stream(strArr);

3、通过 Stream 类中的静态方法 of()

    Stream<String> stream = Stream.of("aa", "bb", "cc");

4、创建无限流，打印出来的结果为：从0开始，每一个元素比上一个大2，无限大下去
```
    Stream<Integer> integerStream = Stream.iterate(0, (x) -> x + 2);
```

中间操作

filter：排除

将list中小于等于20的值排除掉，最后遍历打印

      	// 排除掉小于等于20的元素
	    List<Integer> list = new ArrayList<Integer>(){{
            add(23);
            add(86);
            add(19);
        }};
        Stream<Integer> stream = list.stream()
                .filter((x) -> x > 20);
        stream.forEach(System.out::println);

输出：

23
86

limit：截断

获取并且打印数组的前两个数据

      	// 获取前两个元素
        List<Integer> list = new ArrayList<Integer>(){{
            add(23);
            add(86);
            add(19);
        }};
        list.stream()
                .limit(2)
                .forEach(System.out::println);

输出：

23
86

skip(n)：跳过元素

跳过元素，返回一个冷掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与 limit(n) 互补。

      	// 跳过前两个元素
        new ArrayList<Integer>() {{
            add(23);
            add(86);
            add(19);
        }}.stream()
                .skip(2)
                .forEach(System.out::println);

输出：

distinct：去重

对 list 中的数据进行equals()对比去重。若 list 中存放的是对象，那么需要重写 hashCode() 和 equals() 方法，否则由于对象使用equals()对比得到的结果是false，会导致无法去重。

		// 去掉里面的重复项
        new ArrayList<Integer>() {{
            add(23);
            add(86);
            add(19);
            add(86);
            add(86);
        }}.stream()
                .distinct()
                .forEach(System.out::println);

输出：

23
86
19

map：映射

将元素转换成其他形式或提取信息。接受一个函数作为参数，该函数会应用到每个元素上，并将其映射成一个新到元素。

		// 将每个元素的值增加 100
        new ArrayList<Integer>() {{
            add(23);
            add(86);
            add(19);
        }}.stream()
                .map((i) -> i + 100)
                .forEach(System.out::println);

输出：

123
186
119

sorted：排序

        // 自然排序
        new ArrayList<Integer>() {{
            add(23);
            add(86);
            add(19);
        }}.stream()
                .sorted()
                .forEach(System.out::println);
                
        System.out.println("--------");
        
        // 定制排序，使用 lambda 表达式实现sorted方法参数中的Comparator中的接口，自定义排序方式
        new ArrayList<Integer>() {{
            add(23);
            add(86);
            add(19);
        }}.stream()
                .sorted((num1,num2) -> num2.compareTo(num1))
                .forEach(System.out::println);

输出：

19
23
86
--------
86
23
19

终止操作

allMatch：检查是否匹配所有元素

根据.allMatch 方法中的Lambda表达式，判断每个元素是否都满足条件，全部满足时返回true，有一个不满足则返回false

		// 判断list中每个数组元素下标为1的元素是否都等于3
		boolean allMatch = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 3, 3});
        }}.stream().allMatch((e) -> e[1] == 3);
        System.out.println(allMatch);

输出：

true

anyMatch：检查是否至少匹配一个元素

根据.anyMatch 方法中的Lambda表达式，判断是否至少有一个元素满足条件，至少一个满足时返回true，全都不满足则返回false

		// 判断list中是否至少有一个数组元素下标为2的元素等于4
        boolean anyMatch = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 3, 3});
        }}.stream().anyMatch((e) -> e[2] == 4);
        System.out.println(anyMatch);

输出：

true

noneMatch：检查是否没有匹配所有元素

根据.noneMatch 方法中的Lambda表达式，判断是否所有元素都不满足条件，都不满足时方式true，只要至少有一个元素满足了，就返回false

		// 判断list中是否所有数组元素下标为2的元素都不等于7
        boolean noneMatch = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 3, 3});
        }}.stream().noneMatch((e) -> e[2] == 7);
        System.out.println(noneMatch);

输出：

true

findFirst：返回第一个元素

获取流中第一个元素，我们可以在前面加排序什么的，得到排序后的第一个，然后使用get()方法取出元素进行后续操作。

		// 获取第一个数组元素中下标为1的值
        Optional<Integer[]> optional = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 3, 3});
        }}.stream().findFirst();
        // 如果optional的值 为空，那么可以设置替代值，当然需不需要看你需求
        optional.orElse(new Integer[]{0,0,0});
        System.out.println(optional.get()[1]);

输出：

findAny：返回当前流中的任意元素

        Optional<Integer[]> optional = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 3, 3});
        }}.stream().findAny();
        // 如果optional的值 为空，那么可以设置替代值，当然需不需要看你需求
        optional.orElse(new Integer[]{0,0,0});
        System.out.println(optional.get()[2]);

输出：

count：返回流中元素总个数

        long count = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 3, 3});
        }}.stream().count();
        System.out.println(count);

max：返回流中最大值

根据.max 方法中的Lambda表达式，自定义计算方式排序，得到你认为最大的元素。

		// 获取所有数组元素中，数组2下标最大的数组，并且打印该数组下标2的元素
        Optional<Integer[]> max = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 3, 3});
        }}.stream().max((a1, a2) -> a1[2].compareTo(a2[2]));
        System.out.println(max.get()[2]);

输出：

min：返回流中最大值

根据.max 方法中的Lambda表达式，自定义计算方式排序，得到你最小的元素。

		// 获取所有数组元素中，数组2下标最大的数组，并且打印该数组下标2的元素
        Optional<Integer[]> min = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 3, 3});
        }}.stream().min((a1, a2) -> a1[2].compareTo(a2[2]));
        System.out.println(min.get()[2]);

输出：

reduce：归约

可以将流中元素反复结合起来，得到一个值

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 将100作为基数，将list中的所有元素往100上累加，每加上一个元素，就把加后的值当作x，后一个元素当作y，再往后加
        Integer reduce = list.stream()
                .reduce(100, (x, y) -> x + y);
        System.out.println(reduce);
        // 没有基数，直接累加，但是因为没有起始值，所以结果可能为空，所以使用Optional接收值
        Optional<Integer> reduce1 = list.stream()
                .reduce(Integer::sum);
        System.out.println(reduce1.get());

输出：

155
55

collect：收集

将流转换为其他形式。接收一个Collector接口的实现，用户给Stream中元素做汇总的方法。

汇总

		// 把list中每个数组元素的第3个元素取出来，放到一个新的list中
        ArrayList<Integer[]> list = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 3, 3});
        }};
        List<Integer> collect = list
                .stream()
                .map((a) -> a[2])
                .collect(Collectors.toList());
        collect
                .stream()
                .forEach(System.out::println);

输出：

4
6
3

若我们需要放到特殊的容器中，比如HashSet

		.collect(Collectors.toCollection(HashSet::new));

计算

        ArrayList<Integer[]> list = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 3, 3});
        }};
        // 获取总数 结果 3
        Long collect = list.stream().collect(Collectors.counting());
        // 平均值（每个数组元素的第三个值，取出来算平均值） 结果 4.33333
        Double collect1 = list.stream().collect(Collectors.averagingInt((a) -> a[2]));
        // 求和（每个数组元素的第三个值，取出来求和） 结果 13.0
        Double collect2 = list.stream().collect(Collectors.summingDouble((a) -> a[2]));
        // 获取每个元素下标为2的最大值 结果 6
        Optional<Integer> collect3 = list.stream().map((x)->x[2]).collect(Collectors.maxBy((a1, a2) -> a1.compareTo(a2)));
        // 获取每个元素下标为2的最小值 结果 3
        Optional<Integer> collect4 = list.stream().map((x)->x[2]).collect(Collectors.minBy(Integer::compareTo));
        // 总函数
        DoubleSummaryStatistics collect = list.stream().collect(Collectors.summarizingDouble((e) -> e[2]));
        System.out.println("求和：" + collect.getSum());
        System.out.println("平均值：" + collect.getAverage());
        System.out.println("最大值：" + collect.getMax());

分组

        // 按照每个数组的第二个元素进行分组
        ArrayList<Integer[]> list = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{8, 4, 3});
        }};
        Map<Integer, List<Integer[]>> collect = list.stream().collect(Collectors.groupingBy((e) -> e[1]));
        System.out.println(new Gson().toJson(collect));

输出：

{"3":[[2,3,4],[1,3,6]],"4":[[8,4,3]]}

多级分组

		// 先按照每个数组多第二个元素进行分组，然后每个分组里，按照第一个元素进行分组
        ArrayList<Integer[]> list = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{1, 3, 7});
            add(new Integer[]{8, 4, 3});
        }};
        Map<Object, Map<Object, List<Integer[]>>> collect = list.stream()
                .collect(Collectors.groupingBy((e) -> e[1]
                        ,Collectors.groupingBy((q) -> q[0])
                ));
        System.out.println(new Gson().toJson(collect));

输出：

{"3":{"1":[[1,3,6],[1,3,7]],"2":[[2,3,4]]},"4":{"8":[[8,4,3]]}}

分区

		// 每个数组的第一个元素为1的分到true这一区，不为1的分false区
        ArrayList<Integer[]> list = new ArrayList<Integer[]>() {{
            add(new Integer[]{2, 3, 4});
            add(new Integer[]{1, 3, 6});
            add(new Integer[]{1, 3, 7});
            add(new Integer[]{8, 4, 3});
        }};
        Map<Boolean, List<Integer[]>> collect = list.stream().collect(Collectors.partitioningBy((e) -> e[0] == 1));
        System.out.println(new Gson().toJson(collect));

输出：

{"false":[[2,3,4],[8,4,3]],"true":[[1,3,6],[1,3,7]]}

字符串连接

		// 讲每个数组的第3个元素取出来拼接在一起
        ArrayList<String[]> list = new ArrayList<String[]>() {{
            add(new String[]{"2", "3", "4"});
            add(new String[]{"1", "5", "6"});
        }};
        String collect = list.stream()
                .map((e) -> e[2])
                .collect(Collectors.joining());
        System.out.println(collect);
        
        collect = list.stream()
                .map((e) -> e[2])
                .collect(Collectors.joining("，"));
        System.out.println(collect);

        collect = list.stream()
                .map((e) -> e[2])
                .collect(Collectors.joining("，","前缀-- "," --结尾"));
        System.out.println(collect);

输出：

46
4，6
前缀-- 4，6 --结尾

这篇关于Java8 Stream流的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java8 Stream流

目录

Stream 的三个操作步骤

创建Stream的几种方式

中间操作

filter：排除

limit：截断

skip(n)：跳过元素

distinct：去重

map：映射

sorted：排序

终止操作

allMatch：检查是否匹配所有元素

anyMatch：检查是否至少匹配一个元素

noneMatch：检查是否没有匹配所有元素

findFirst：返回第一个元素

findAny：返回当前流中的任意元素

count：返回流中元素总个数

max：返回流中最大值

min：返回流中最大值

reduce：归约

collect：收集

汇总

计算

分组

多级分组

分区

字符串连接

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯