stream流常见操作(详细)

1. Filiter   过滤
2. Limit(long maxSize)&&skip   长度不超过maxSize&&跳过指定数量元素
3. Concat && distinct    连接两个流&&返回流中的不同元素
4. Sorted自然排序及comparator   排序
5. Map流终止操作forEach和count      遍历&&统计
6. 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);

结果: