stream流常见操作(详细)

原创已于 2022-11-01 18:47:49 修改 · 861 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #jvm #开发语言

于 2022-11-01 09:59:46 首次发布

初级专栏收录该内容

10 篇文章

订阅专栏

本文介绍 Java 中 Stream API 的多种实用操作，包括过滤、限制、跳过、连接、去重、排序及转换等方法，并通过具体示例展示了 Lambda 表达式的简洁应用。

Filiter 过滤
Limit(long maxSize)&&skip 长度不超过maxSize&&跳过指定数量元素
Concat && distinct 连接两个流&&返回流中的不同元素
Sorted自然排序及comparator 排序
Map流终止操作forEach和count 遍历&&统计
Map&&mapToInt

Lambda表达式

格式(形式参数)->{代码块}，->表示指向动作，代码块表示我们的方法内容。

形参只有一个可以省略()和参数类型,代码块里只有一条语句的情况下可以省略return。

Stream之Filiter

filter(Predicate<? super T> predicate)

返回由与此给定谓词匹配的此流的元素组成的流。可以起到判断过滤作用

 ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("猪");
        list.add("猪猪侠");
        list.add("赵孙乾");
        ArrayList<String> list1 = new ArrayList<>();
        //输出姓张的
        list.stream().filter((s)->{
            return s.startsWith("猪");
        }).forEach(System.out::println);
        System.out.println("-----");
       //省略版Lambda
       list.stream().filter(s -> s.startsWith("猪")).forEach(System.out::println);
        System.out.println("-----");
       //输出姓猪的且长度为三的姓名
       list.stream().filter(s->s.startsWith("猪")).filter(s->s.length()==3).forEach(s -> System.out.println(s));

结果:

Stream之Limit&&skip

limit(long maxSize)

返回由此流的元素组成的流，截短长度不能超过 maxSize 。

skip(long n)

在丢弃流的第一个 n元素后，返回由该流的 n元素组成的流

ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("猪");
        list.add("猪猪侠");
        list.add("王静王");
        list.add("猪侠猪");
        list.add("赵孙乾");

        //取前三个元素
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("----");
        //跳过前两个元素
        list.stream().skip(2).forEach(System.out::println);
        System.out.println("----");
        //跳过前两个 去后面的前三个
        list.stream().skip(2).limit(3).forEach(System.out::println);
        System.out.println("----");

结果:

Stream之Concat&&distinct

concat(Stream<? extends T> a, Stream<? extends T> b)

创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。

distinct()

返回由该流的不同元素（根据 Object.equals(Object) ）组成的流。

        //取前三个为第一个流
        Stream<String> stream1 = list.stream().limit(3);
        //取除第一个之后的为第二个流
        Stream<String> stream2 = list.stream().skip(1);
        //合并1 2流
        Stream.concat(stream1,stream2).forEach(System.out::println);
        System.out.println("-----");
        //合并1 2流 并且去除重复元素
        Stream.concat(stream1,stream2).distinct().forEach(s -> System.out.println(s));

结果：

        会发现出现了IllegalStateException错误并且提示流已经被操作或者被关闭

        此时我们需要引出流的三个过程来解释这个问题

生成流：

通过数据源(集合,数组等)生成流 list.stream()

中间操作：

           一个流中间可以跟零个或者多个中间操作,目的是打开流,经过数据过滤/映射，返回一个新的流,交给下一个操作使用。 list.stream.filiter()等

终结操作：

一个流只能有一个终结操作,操作执行后,流就被用"光"了,无法再被操作,所以这一定是流的最后一个操作。 forEach()等

出现IllegalStateException问题原因:

所以我们可以找到出现这个问题的原因了。

我们先已经对stream1和stream2进行合并了,所以流已经被用光了

第二次调用就会提示错误

Sorted自然排序及comparator

sorted()

返回由此流的元素组成的流，根据自然顺序排序。

sorted(Comparator<? super T> comparator)

返回由该流的元素组成的流，根据提供的 Comparator进行排序。

ArrayList<String> list = new ArrayList<>();
        list.add("dsadsads");
        list.add("wsdjj");
        list.add("sdskk");
        list.add("a");

        //stream自然排序
         list.stream().sorted().forEach(System.out::println);
        System.out.println("----");
        //按字符串长度排序 长度一样按照自然排序                                                                                                                                                                                                                                                                                                                                                   
        list.stream().sorted((s1,s2)->{
            int num=s1.length()-s2.length();
            int num2=num==0?s1.compareTo(s2):num;
            return num2;
         }).forEach(System.out::println);

结果:

Map流终止操作forEach和count

forEach(Consumer<? super T> action)

对此流的每个元素执行操作。

count()

返回此流中的元素数。

        ArrayList<String>list=new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        //过滤并统计元素总数
        long count = list.stream().filter(s -> s.equals("10")).count();
        list.stream().filter(s -> s.equals("10")).forEach(System.out::println);
        System.out.println(count);

结果:

Map&&mapToInt

map(Function<? super T,? extends R> mapper)

返回由给定函数应用于此流的元素的结果组成的流。

mapToInt(ToIntFunction<? super T> mapper)

返回一个 IntStream ，其中包含将给定函数应用于此流的元素的结果。

        ArrayList<String>list=new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        //list集合里的字符串转为Integer
        list.stream().map(Integer::parseInt).forEach(System.out::println);
        System.out.println("----");
       //mapToInt也有此一样的功能
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        System.out.println("-----");
        //统计元素此流的元素结果
        int sum = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);

结果: