zoukankan      html  css  js  c++  java
  • Java8 Stream终端操作使用详解

    话不多说,自己挖的坑自己要填完,今天就给大家讲完Java8中Stream的终端操作使用详解。Stream流的终端操作主要有以下几种,我们来一一讲解。

    • forEach()
    • forEachOrdered()
    • toArray()
    • reduce()
    • collect()
    • min()
    • max()
    • count()
    • anyMatch()
    • allMatch()
    • noneMatch()
    • findFirst()
    • findAny()

    终端操作代码实例详解

    1、forEach():遍历流中的每一个元素,按照指定的方法执行,执行顺序不一定按照流的顺序。

    // foreach:遍历流中每一个元素,执行顺序按照流的顺序
    Stream.of(1,2,3,4,5,6).forEach(System.out::println);
    // foreach:遍历流中每一个元素,执行顺序不一定按照流的顺序,.parallel()表示创建一个并行流
    Stream.of(1,2,3,4,5,6).parallel().forEach(System.out::println);

    运行结果:

    1

    2

    3

    4

    5

    6

    2

    1

    6

    5

    3

    4

    2、forEachOrdered():遍历流中的每一个元素,按照指定的方法执行,执行顺序按照流的顺序。

    // forEachOrdered():遍历流中每一个元素,执行顺序按照流的顺序
    Stream.of(1,2,3,4,5,6).forEachOrdered(System.out::println);
    // forEachOrdered:遍历流中每一个元素,执行顺序按照流的顺序,.parallel()表示创建一个并行流
    Stream.of(1,2,3,4,5,6).parallel().forEachOrdered(System.out::println);

    运行结果:

    1

    2

    3

    4

    5

    6

    1

    2

    3

    4

    5

    6

    3、toArray():将流中的元素放入到一个数组中

    // toArray():将流中的元素放入到一个数组中
    String[] strings = Stream.of("ma", "zhi", "chu").toArray(String[]::new);
    System.out.println(Arrays.toString(strings));

    运行结果:[ma, zhi, chu]

     

    4、reduce():这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值(种子),然后依照运算规则(BinaryOperator),和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说,字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。

    // reduce():字符串拼接
    String reduceStr1 = Stream.of("ma", "zhi", "chu").reduce("", String::concat);
    String reduceStr2 = Stream.of("ma", "zhi", "chu").reduce("", (x,y)->x+y);
    System.out.println(reduceStr1);
    System.out.println(reduceStr2);
    // reduce():求和,identity(起始值)为0
    Integer total1 = Stream.of(1,2,3,4).reduce(0, Integer::sum);
    Integer total2 = Stream.of(1,2,3,4).reduce(0, (x, y) -> x +y);
    System.out.println(total1);
    System.out.println(total2);
    // 求和,sumValue = 10, 无起始值
    Integer total3 = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
    System.out.println(total3);
    // reduce():求最小值
    double minValue = Stream.of(-1.1, 8.8, -2.2, -6.6).reduce(Double.MAX_VALUE, Double::min);
    System.out.println(minValue);

    运行结果:

    mazhichu

    mazhichu

    10

    10

    10

    -6.6

    5、collect():是Stream的一个函数,负责收集流。前面我们说中间操作是将一个流转换成另一个流,这些操作是不消耗流的,但是终端操作会消耗流,产生一个最终结果,collect()就是一个规约操作,将流中的结果汇总。结果是由传入collect()中的Collector定义的。

    // collect():负责收集流,将结果汇总,比如将下面的流中的结果汇总到一个集合中去
    List<Integer> skipNum = IntStream.range(1,100).skip(90)
    .boxed()
    .collect(Collectors.toList());
    System.out.println(skipNum);
    

    运行结果:[91, 92, 93, 94, 95, 96, 97, 98, 99]

    6、min():返回流中的最小值

    // min():返回流中的最小值
    List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6);
    Integer minNum = nums.stream().min(Integer::compareTo).get();
    Integer min = nums.stream().min((x,y) -> x.compareTo(y)).get();
    System.out.println(minNum);
    System.out.println(min);

    运行结果:

    1

    1

    7、max():返回流中的最大值

    // max():返回流中的最大值
    List<Integer> num = Arrays.asList(1, 2, 3, 4, 5, 6);
    Integer maxNum = num.stream().max(Integer::compareTo).get();
    Integer max = num.stream().max(Comparator.comparing(Function.identity())).get();
    System.out.println(maxNum);
    System.out.println(max);

    运行结果:

    6

    6

    8、count():返回流中元素的数量

    // count():返回流中元素的数量
    List<Integer> ls = Arrays.asList(1,2,3,4,5);
    long count = ls.stream().count();
    long count1 = ls.stream().filter(l -> l > 2).count();
    System.out.println(count);
    System.out.println(count1);

    运行结果:

    5

    3

    9、anyMatch():Stream 中只要有一个元素符合传入的断言,就返回 true,否则返回false。

    // anyMatch():判断流中数据是否有一个复合断言
    List<Integer> ins = Arrays.asList(1,2,3,4,5);
    boolean b = ins.stream().anyMatch(l -> l > 2);
    boolean b1 = ins.stream().anyMatch(l -> l > 5);
    System.out.println(b);
    System.out.println(b1);
    // anyMatch():判断流中数据是否有一个复合断言,如果流为空,永远返回false
    List<Integer> inss = Arrays.asList();
    boolean b2 = inss.stream().anyMatch(l -> l > 2);
    System.out.println(b2);
    

    运行结果:

    true

    false

    false

    10、allMatch():Stream 中所有元素都符合传入的断言时返回 true,否则返回false,流为空时总是返回true。

    // allMatch():判断流中元素是否都符合断言条件
    List<Integer> ints = Arrays.asList(1,2,3,4,5);
    boolean c = ints.stream().allMatch(l -> l > 0);
    boolean c1 = ints.stream().allMatch(l -> l > 1);
    System.out.println(c);
    System.out.println(c1);
    // allMatch():判断流中元素是否都符合断言条件,如果流为空,永远返回true
    List<Integer> emptyList = new ArrayList<>();
    boolean c2 = emptyList.stream().allMatch(e -> e > 1);
    System.out.println(c2);

    运行结果:

    true

    false

    true

    11、noneMatch():Stream 中所有元素都不满足传入的断言时返回 true,否则返回false。

    // noneMatch():判断流中元素是否都不符合传入的断言条件
    List<Integer> numList = Arrays.asList(1,2,3,4,5);
    boolean d = numList.stream().noneMatch(l -> l > 6);
    boolean d1 = numList.stream().noneMatch(l -> l > 1);
    System.out.println(d);
    System.out.println(d1);
    // noneMatch():判断流中元素是否都不符合传入的断言条件,流为空时永远返回true
    List<Integer> numist = Arrays.asList();
    boolean d2 = numist.stream().noneMatch(l -> l > 6);
    System.out.println(d2);

    运行结果:

    true

    false

    true

    12、findFirst():总是返回流中的第一个元素,如果流为空,返回一个空的Optional.

    // findFirst():返回流中的第一个元素
    List<Integer> integers = Arrays.asList(1, 2, 3);
    Optional<Integer> first = integers.stream().findFirst();
    System.out.println(first);
    System.out.println(first.isPresent()); // 判断是否不等于null,isPresent()相当于!=null的判断
    System.out.println(first.get());
    //findFirst():返回流中的第一个元素,如果流为空,返回一个空的Optional
    List<Integer> lls = Collections.EMPTY_LIST;
    Optional<Integer> first1 = lls.stream().findFirst();
    System.out.println(first1);
    System.out.println(first1.isPresent());

    运行结果:

    Optional[1]

    true

    1

    Optional.empty

    false

    13、findAny():返回流中的任意一个元素即可,如果流为空,返回一个空的Optional.

    // findAny():返回流中任意一个元素,
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
    Optional<Integer> any = list.stream().findAny();
    // 并行流下每次返回的结果会不同
    // Optional<Integer> any = list.stream().parallel().findAny();
    System.out.println(any);
    System.out.println(any.isPresent());
    System.out.println(any.get());
    // findAny():返回流中任意一个元素,如果流为空,返回一个空的Optional
    List<Integer> list1 = Arrays.asList();
    Optional<Integer> any1 = list1.stream().findAny();
    System.out.println(any1);
    System.out.println(any1.isPresent());

    运行结果:

    Optional[1]

    true

    1

    Optional.empty

    false

    以上就是Stream的13个终端操作,基本上可以覆盖我们工作中的大部分操作,所以小伙伴朋友有必要掌握​。​

    总结

    Stream有以下特性及优点:

    无存储。Stream不是一种数据结构,它只是某种数据源的一个视图,数据源可以是一个数组,Java容器或I/O channel等。

    为函数式编程而生。对Stream的任何修改都不会修改背后的数据源,比如对Stream执行过滤操作并不会删除被过滤的元素,而是会产生一个不包含被过滤元素的新Stream。

    惰式执行。Stream上的操作并不会立即执行,只有等到用户真正需要结果的时候才会执行。

    可消费性。Stream只能被“消费”一次,一旦遍历过就会失效,就像容器的迭代器那样,想要再次遍历必须重新生成。

    对于无限数量的流,有些操作是可以在有限的时间完成的,比如limit(n) 或 findFirst(),这些操作可是实现"短路"(Short-circuiting),访问到有限的元素后就可以返回。

  • 相关阅读:
    设计模式之观察者模式
    设计模式之模板方法模式
    设计模式之代理模式(全面讲解)
    设计模式之工厂模式(包含三种模式)
    设计模式之单例模式(包含三种方式)
    opencv+vs2015 堆内存析构异常
    用python来压缩文件
    GPT安装ubuntu的问题
    Two Sum and add Two Numbers
    [LeetCode] Palindrome Partitioning II
  • 原文地址:https://www.cnblogs.com/mazhichu/p/11983451.html
Copyright © 2011-2022 走看看