java stream 的使用

已于 2022-05-25 16:59:02 修改
阅读量446 收藏 3
点赞数
分类专栏： Java 文章标签： java
于 2022-05-25 15:49:32 首次发布
by 战鸟
本文链接：https://blog.csdn.net/qsyjrz206/article/details/124967665
版权

Stream

流的生成

通过集合生成

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
Stream<Integer> stream = list .stream();

通过值生成

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

通过文件生成

Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());

通过函数生成

  • iterator
        /** 
         * 该方法通过迭代器生成无限流，需要limit方法进行截断
         * iterate: 内为迭代方法，即生成流的规则
         * limit: 参数为生成的数量
         */
        Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(5);
  • generator
        /**
         * 该方法通过迭代器生成无限流，需要limit方法进行截断
         * generate: 内为生成器方法，即生成流的规则
         * limit: 参数为生成的数量
         */
        Stream<Double> stream = Stream.generate(Math::random).limit(5);

流的类型

Stream， IntStream， DoubleStream， LongStream，四种类型的流都继承自BaseStream，其中Stream代表引用类型的流，四者之间可以通过，mapToObj，mapToInt，mapToDouble，mapToLong进行转化。

操作类型

  • 中间操作

一个流可以后面跟随零个或多个中间操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的，仅仅调用到这类方法，并没有真正开始流的遍历，真正的遍历需等到终端操作时，常见的中间操作有下面即将介绍的 filter、map 等。

  • 终端操作

一个流有且只能有一个终端操作，当这个操作执行后，流就被关闭了，无法再被操作，因此一个流只能被遍历一次，若想在遍历需要通过源数据在生成流。终端操作的执行，才会真正开始流的遍历。

方法

filter

  • 筛选
  • 参数为条件，返回所有该条件为true的元素
  • 中间操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Stream stream = list.stream().filter(i -> i > 3);
        stream.forEach(System.out::println);

结果

4
5
6

Process finished with exit code 0

distinct

  • 去重
  • 中间操作
        List<Integer> list = Arrays.asList(1, 1, 2, 3, 3, 4);
        Stream stream = list.stream().distinct();
        stream.forEach(System.out::println);

结果

1
2
3
4

sorted

  • 排序
  • 中间操作
        List<String> list = Arrays.asList("java", "python", "go");
        Stream stream;
        //自然升序
        stream = list.stream().sorted();
        stream.forEach(System.out::println);
        System.out.println("====================");

        //自然降序
        stream = list.stream().sorted(Comparator.reverseOrder());
        stream.forEach(System.out::println);
        System.out.println("====================");

        //对象升序
        stream = list.stream().sorted(Comparator.comparing(String::length));
        stream.forEach(System.out::println);
        System.out.println("====================");

        //对象降序
        stream = list.stream().sorted(Comparator.comparing(String::length).reversed());
        stream.forEach(System.out::println);
        System.out.println("====================");

        //自定义排序规则
        stream = list.stream().sorted(Comparator.comparing(s -> s.charAt(1)));
        stream.forEach(System.out::println);
        System.out.println("====================");

        //多规则排序
        stream = list.stream().sorted(Comparator.comparing(String::length).thenComparing(String::hashCode));
        stream.forEach(System.out::println);

结果

go
java
python
====================
python
java
go
====================
go
java
python
====================
python
java
go
====================
java
go
python
====================
go
java
python

takeWhile

  • 循环保留
  • 保留第一个不满足条件的元素之前的所有元素，故如果将示例中条件改为i>4，则不会保留任何元素，返回为空
  • 中间操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Stream<Integer> stream = list.stream().takeWhile(i -> (i < 4));
        stream.forEach(System.out::println);

结果

1
2
3

dropWhile

  • 循环舍弃
  • 舍弃第一个不满足条件的元素之前的所有元素，故如果将示例中条件改为i>4，则不会舍弃任何元素，返回为从1到5
  • 中间操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Stream<Integer> stream = list.stream().dropWhile(i -> (i < 4));
        stream.forEach(System.out::println);

结果

4
5

peek

  • 遍历
  • peek为中间操作，forEach为终端操作，二者仅这点不同，peek常用来辅助调制
  • 中间操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        list.stream()
                .peek(System.out::println)
                .dropWhile(i -> (i < 4))
                .forEach(System.out::println);

结果

1
2
3
4
4
5
5

limit

  • 前截取
  • 参数为返回的元素个数
  • 中间操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Stream stream = list.stream().limit(3);
        stream.forEach(System.out::println);

结果

1
2
3

skip

  • 后截取
  • 参数为跳过的元素个数
  • 中间操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Stream stream = list.stream().skip(2);
        stream.forEach(System.out::println);

结果

3
4
5
6

map

  • 映射
  • 通过参数中的方法将元素映射为另个元素
  • 中间操作
        List<String> list = Arrays.asList("java", "python", "go");
        Stream stream = list.stream().map(String::length);
        stream.forEach(System.out::println);

结果

4
6
2

flatMap

  • 扁平化流
  • 将每一个值都转换成流，可以理解将多层结构转为单层的流
  • 中间操作
        /**
         * 经过map之后的类型为 Stream<String[]>,可以认为是两层结构
         * 经过flatMap后将map结果的流转换成扁平的单层流
         */
        List<String> list = Arrays.asList("java 17", "python 3.9", "go 1.18");
        Stream stream = list.stream()
                .map(w -> w.split(" "))
                .flatMap(Arrays::stream);
        stream.forEach(System.out::println);

结果

java
17
python
3.9
go
1.18

allMatch

  • 匹配所有元素
  • 返回值为boolean，若参数对于所有元素均为true，则返回true，否则返回false；与noneMatch含义相反
  • 中间操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        if (list.stream().allMatch(i -> i > 4)) {
            System.out.println("所有元素值都大于4");
        } else {
            System.out.println("不是所有元素值都大于4");
        }

结果

不是所有元素值都大于4

anyMatch

  • 匹配其中一个元素
  • 返回值为boolean，若参数对于任一元素为true，则返回true，否则返回false
  • 中间操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        if (list.stream().anyMatch(i -> i > 4)) {
            System.out.println("存在大于4的元素");
        } else {
            System.out.println("不存在大于4的元素");
        }

结果

存在大于4的元素

noneMatch

  • 所有元素不匹配
  • 返回值为boolean，若参数对于所有元素均为false，则返回true，否则返回false；与allMatch含义相反
  • 中间操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        if (list.stream().noneMatch(i -> i > 4)) {
            System.out.println("不存在大于4的元素");
        } else {
            System.out.println("存在大于4的元素");
        }

结果

存在大于4的元素

count

  • 统计元素个数
  • 返回流中的元素的个数，返回值为long型
  • 终端操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        long count = list.stream().count();
        System.out.println(count);

结果

5

findFirst

  • 查找第一个
  • 返回第一个元素，通常配合filter使用，返回满足过滤条件的第一个元素，返回类型为Optional
  • 终端操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Optional result = list.stream().filter(i -> i > 3).findFirst();
        System.out.println(result.orElse(-1));

结果

4

findAny

  • 查找随机一个
  • 返回随机一个元素，通常配合filter使用，返回满足过滤条件的随机一个元素，返回类型为Optional，在数据较少且串行的情况下，一般返回第一个，即与findFirst返回一致；若是数据较多或并行时，返回元素随机，findAny相比findFirst，更加高效
  • 终端操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Optional result = list.stream().filter(i -> i > 3).findAny();
        System.out.println(result.orElse(-1));

结果

4

reduce

  • 裁减计算（其实不知道该怎么翻译好）
  • 第一个参数是初始值，第二个参数为操作，相当于将初始值添加到流的头部，然后连续调用第二个参数的方法，对于累加、累乘的操作，更好理解
  • 终端操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        int sum = list.stream()
                .reduce(0, Integer::sum);
        int product = list.stream()
                .reduce(1, (a, b)->a * b);
        System.out.println(sum);
        System.out.println(product);

结果

15
120

max

  • 最大值
  • 返回最大的元素，参数为比较方法，通常为compare方法
  • 终端操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Optional<Integer> max = list.stream()
                .max(Integer::compareTo);
        System.out.println(max.orElse(-1));

结果

5

min

  • 最小值
  • 返回最小的元素，参数为比较方法，通常为compare方法
  • 终端操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Optional<Integer> min = list.stream()
                .min(Integer::compareTo);
        System.out.println(min.orElse(-1));

结果

1

foreach

  • 遍历
  • 终端操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        list.forEach(System.out::println);

结果

1
2
3
4
5

collect

  • 返回集合
  • 终端操作
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> intList = list.stream()
                .collect(Collectors.toList());

通过Collectors.toXXX()方法，可以转换为其他集合类型，如：

toList： 转为List

toSet： 转为Set

toMap： 转为Map

joining

  • 拼接
  • 将元素通过参数拼接起来
  • collect操作
        List<String> list = Arrays.asList("java 17", "python 3.9", "go 1.18");
        String str = list.stream()
                .collect(Collectors.joining(";"));
        System.out.println(str);

结果

java 17;python 3.9;go 1.18

groupingBy

  • 分组
  • 将元素按参数规则分组，分组方法可以嵌套，可以自定义
  • collect操作
        //单层分组
        List<String> list = Arrays.asList("java", "python", "go", "delphi", "groovy", "perl");
        Map<Integer, List<String>> map = list.stream()
                .collect(Collectors.groupingBy(String::length));
        System.out.println(map);
        System.out.println("===================");

//        //两层分组，二层为自定义条件
        Map<Integer, Map<String, List<String>>> map2 = list.stream()
                .collect(Collectors.groupingBy(String::length,
                        Collectors.groupingBy(s -> s.charAt(0) + "")));
        System.out.println(map2);

结果

{2=[go], 4=[java, perl], 6=[python, delphi, groovy]}
===================
{2={g=[go]}, 4={p=[perl], j=[java]}, 6={p=[python], d=[delphi], g=[groovy]}}

partitioningBy

  • 分组
  • 参数返回为boolean型，根据布尔值分组，最多分两组
  • collect操作
        List<String> list = Arrays.asList("java", "python", "go", "delphi", "groovy", "perl");
        Map<Boolean, List<String>> map = list.stream()
                .collect(Collectors.partitioningBy(s -> s.length() > 4));
        System.out.println(map);

结果

{false=[java, go, perl], true=[python, delphi, groovy]}
战鸟
关注
专栏目录
JAVA中的Stream流的使用详解
2302_79993788的博客
08-23 839
下面我们来举个例子来感受一下Stream有多优雅Stream的类型我们可以对流进行中间操作或者终端操作。小伙伴们可能会疑问？
Java Stream流介绍和使用说明
最新发布
weixin_42704604的博客
07-01 330
Stream作为java8中增加的一个非常重要特性，为我们提供了对集合的一系列操作，简化了对集合元素的操作复杂度，让我们可以更加专注与业务逻辑的实现，stream的操作一般需要和Lambda表达式进行结合使用，达到简便的操作及清晰的代码。Stream流不是数据结构，不会改变源数据，而是通过对源数据的操作来产生新的数据流。Stream流支持链式操作，可以进行多个操作的组合，使得代码更加简洁。Stream流支持延迟操作，只有在终止操作时才会进行计算，可以提高程序的性能。
java stream使用
xiaofeixia__9999的专栏
01-29 452
java stream的特性能大大提高代码的可观赏性，而且使用起来非常方便。由于项目开发中经常用到一些stream的操作，记录下来回忆之用。也供大家参考  
Java中stream()的使用
qq_51976556的博客
04-16 2511
流的中间操作不会立即执行，只有在遇到终端操作时才会执行。这意味着中间操作会形成一种流水线，只有当结果真正需要时才开始计算，这有助于优化性能，特别是在处理大数据或复杂操作链时。API 提供了一种高级的抽象，使我们可以将集合转换成一种流式的处理模式，从而能大链式地执行一系列操作。：流的操作通常是函数式的，意味着你可以传递 lambda 表达式或方法引用来执行操作。：流不会改变原有的数据结构，它们只提供了一种在数据源上执行操作的方法。通过重复使用给定的操作，将流中的元素组合起来，返回一个。
Java 中 Stream 流的使用方法
qq_58417838的博客
12-25 2281
返回一个顺序流，即元素是按顺序处理的。这意味着对于大多数操作，它们将按照集合中元素的顺序依次执行。1.1、通过Collection对象的stream()或parallelStream()方法。1.4、通过IntStream、LongStream、DoubleStream接口中的of、1.3、通过Stream接口的of()、iterate()、generate()方法。使用一个终止操作来产生一个结果（新的对象）。该操作会强制之前的延迟操作立即执行，在此之后，该。操作是延迟执行的，会等到需要结果的时候才执行。
java中Stream的使用
m0_60491441的博客
07-25 399
java中Stream的使用
Java Stream使用（学习资料）
06-17
Java Stream 使用指南 Java Stream 是 Java 8 中引入的函数式编程接口，它极大的方便了开发人员处理集合类数据的效率。本文将详细介绍 Java Stream 的基本概念、使用方法和应用场景。 一、什么是 Java Stream API...
Java Stream 使用详解
01-20
Stream是 Java 8新增加的类，用来补充集合类。 　Stream代表数据流，流中的数据元素的数量可能是有限的，也可能是无限的。 　Stream和其它集合类的区别在于：其它集合类主要关注与有限数量的数据的访问和有效管理...
java使用stream对日期排序
11-17
在Java编程中，Stream API是Java 8引入的一个强大特性，它允许我们以声明性方式处理数据集合。本文将深入探讨如何使用Stream API对日期进行排序。日期排序在数据分析、日志处理、报表生成等场景中非常常见。下面我们...
java stream
12-02
java stream doc.
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
java的stream的使用
CiZhiYiHeng_的博客
08-19 2386
stream流式思想类似工厂的流水线，在工厂中，原材料经过很多步工序，每步工序实现一个功能，最终得到我们需要的产品。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RMlmn67u-1660866950464)(https://tse1-mm.cn.bing.net/th/id/OIP-C.A9go0od39qPlXqzbRCgyRwHaDg?...
Java Stream 流使用
dvrdf的博客
05-03 435
​ Java Stream 是在 Java 8 中引入的一种用于处理集合数据的新 API，它提供了一种更为简便、高效、灵活的方式来对集合中的数据进行操作。Stream 的出现使得 Java 集合框架更加完善，可以大大减少对集合中数据的遍历和操作代码的编写，而且支持并行处理，使得处理大数据集合时性能更佳。
Java stream的常见用法
chishepao1742的博客
11-29 125
不讲原理，只说用法。 1，集合遍历 public class StreamTest { public static void main(String[] args) { //1 遍历 List<String>...
Java Stream常见用法汇总，开发效率大幅提升
程序员小明1024
01-19 778
.markdown-body { line-height: 1.75; font-weight: 400; font-size: 16px; overflow-x: hidden; color: rgba(37, 41, 51, 1) } .markdown-body h1, .markdown-body h2, .markdown-body h3, .markdown-body h4, .ma...
Java Stream 常用方法【详尽篇】
Java Pro
07-25 4939
Java8 版本引入的重要特性之一, 对于集合（例如 List、Map、Set 等）进行处理和操作的高级抽象.Stream API 提供了一种更为简洁高效的的方式来处理集合数据, 可读性较高, 特别在数据的过滤、转换、聚合时的操作很简单方便快捷.
java stream用法
qq_31337311的博客
09-04 235
public class StreamProject { private List&lt;Student&gt; students; @Before public void before(){ students=new ArrayList&lt;&gt;(); for(int i=0;i&lt;5;i++){ S...
Java8中stream相关用法
weixin_43744920的博客
09-17 454
Java8中stream相关方法 filter filter 方法用于通过设置的条件过滤出元素，举例： public static void main(String[] args) { // 创建一个list集合 List<String> list = Arrays.asList("An", "", "ordinary", "collection");...
JAVA stream使用详解
06-08
Java Stream 是 Java 8 中新增的一个 API，用于处理集合数据。它提供了一种更加简洁、高效的方式来操作集合，可以让代码更加简洁、易读、易维护。下面是 Java Stream 的基本使用方法： 1. 创建流 Java Stream 可以从多种数据源中创建，比如集合、数组、文件等。例如，从集合创建一个 Stream 可以使用以下代码： ```java List<String> list = new ArrayList<>(); Stream<String> stream = list.stream(); ``` 2. 中间操作 中间操作是指对 Stream 进行操作，返回一个新的 Stream。常见的中间操作包括：filter、map、sorted、distinct 等。例如，下面的代码使用 filter 操作过滤出长度大于 5 的字符串： ```java List<String> list = Arrays.asList("apple", "banana", "orange", "watermelon"); Stream<String> stream = list.stream().filter(s -> s.length() > 5); ``` 3. 终止操作 终止操作是指对 Stream 进行最终的操作，返回一个非 Stream 的结果。常见的终止操作包括：forEach、reduce、collect、count 等。例如，下面的代码使用 forEach 操作输出过滤后的字符串： ```java List<String> list = Arrays.asList("apple", "banana", "orange", "watermelon"); list.stream().filter(s -> s.length() > 5).forEach(System.out::println); ``` 4. 短路操作 短路操作是指对 Stream 进行操作时，只要满足一定条件就可以停止操作，不必对整个流进行操作。常见的短路操作包括：findFirst、findAny、allMatch、anyMatch、noneMatch 等。例如，下面的代码使用 findAny 操作找到第一个长度大于 5 的字符串： ```java List<String> list = Arrays.asList("apple", "banana", "orange", "watermelon"); Optional<String> result = list.stream().filter(s -> s.length() > 5).findAny(); ``` 以上就是 Java Stream 的基本使用方法，需要注意的是，Stream 是一次性的，一旦进行了终止操作，就不能再对该 Stream 进行操作。同时，Stream 也是惰性求值的，只有在终止操作时才会进行真正的计算。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值