还在用迭代器处理集合吗？试试Stream，真香

时间  2020-05-08 标签 还在 迭代 处理 集合 试试 stream

前言

上一篇博客一文带你深刻了解 Lambda 表达式和方法引用我给你们介绍了 Java8 函数式特性中的 Lambda，这篇文章我将继续讨论 stream 流的用法html

声明：本文首发于博客园，做者：后青春期的Keats；地址：https://www.cnblogs.com/keatsCoder/ 转载请注明，谢谢！java

Show Time

首先给你们看一段代码，让你们直观感觉下 Java7 和 Java8 遍历处理集合的不一样mysql

Dish 是一个菜肴对象，calories 属性表示该菜品的卡路里值，name 则是菜品的名称。咱们须要过滤出卡路里小于400、而后根据卡路里值升序、接着拿到他们的名称列表并返回程序员

Java7sql

public static List<String> getLowCaloricDishesNamesInJava7(List<Dish> dishes){
    List<Dish> lowCaloricDishes = new ArrayList<>();
    for(Dish d: dishes){
        if(d.getCalories() < 400){
            lowCaloricDishes.add(d);
        }
    }
    List<String> lowCaloricDishesName = new ArrayList<>();
    Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
        public int compare(Dish d1, Dish d2){
            return Integer.compare(d1.getCalories(), d2.getCalories());
        }
    });
    for(Dish d: lowCaloricDishes){
        lowCaloricDishesName.add(d.getName());
    }
    return lowCaloricDishesName;
}

Java8app

public static List<String> getLowCaloricDishesNamesInJava8(List<Dish> dishes){
    return dishes.stream()
        .filter(d -> d.getCalories() < 400)
        .sorted(comparing(Dish::getCalories))
        .map(Dish::getName)
        .collect(toList());
}

若是须要多核并行处理，则只需调用 dishes.parallelStream() 便可ide

在 Java8 以前，程序员须要经过 2次遍历 + 一次集合排序才能完成的工做，Java8 只须要一个链式调用就能够解决。这就是 stream 的强大之处函数

img

认识流

流是什么

流是 Java API 的新成员，容许程序员以声明式的方式处理集合数据，而且支持链式调用、支持并行处理。用流处理的集合数据高效且易读。优化

流与集合的异同

  1. 集合的主要功能是以必定的时间和空间复杂度存储和访问元素，而流主要是用于元素计算
  2. 集合中的元素能够随意添加和删除，而流不能添加和删除元素
  3. 流的元素是按需计算的，只有当用到时他才会参与计算，而集合中的元素必须提早全都准备好
  4. 流只能遍历一次,下面的代码会报错 java.lang.IllegalStateException: stream has already been operated upon or closed 流已经被消费掉
List<String> names = Arrays.asList("Java8", "Lambdas", "In", "Action");
Stream<String> s = names.stream();
s.forEach(System.out::println);
s.forEach(System.out::println);
  1. 集合采用外部迭代，流采用内部迭代。内部迭代意味着 Java 能够替你选择更优的迭代策略和并行处理。而外部迭代若是程序员想着作个更有的迭代/采用并行就至关于“下次必定”😅了

流操做分类

对流的操做能够分为两类，能够继续执行下一个流操做的称为中间操做(方法的返回值是 Stream)，关闭流的操做称为终止操做。code

中间操做

除非流水线上执行终端操做，不然中间操做不会执行任何处理。流会对中间操做进行合并、短路等优化

终端操做

终端操做会从流的流水线生成结果，返回一个非 Stream 的任意类型值

使用流

筛选和切片

筛选

filter(Predicate<? super T> predicate) 方法能够将流中知足某条件的元素筛选出来。该方法接收一个谓词函数，返回流。好比要选出某个苹果集合中红色的苹果

List<Apple> appleList = new ArrayList<>();
List<Apple> redAppleList = appleList.stream().filter(a -> "red".equals(a.getColor())).collect(Collectors.toList());

去重

distinct() 方法会根据元素的 hashCode() 和 equals() 方法对流中元素进行去重操做

截断

limit(n) 方法会返回流的前 n 个元素，对于有序集合List，流会按照添加顺序返回前 n 个元素，而无序集合则不会

跳过

skip(n) 方法会跳过流的前 n 个元素，能够经过 skip(m).limit(n) 返回列表中第 m - (m+n) 区间的元素，相似与 mysql 中的 limit m,n

映射

对流中的每一个元素应用函数

map(Function<? super T, ? extends R> mapper) 方法。该方法接收一个 Function 函数，对流中的每个元素使用。而后能够返回任意类型的对象。有了该方法，就能够结合 Lambda 表达式对集合中的元素使用函数进行各类转换

流的扁平化

flatMap() 能够将流操做中多个流合并成一个流的多个元素。举个例子：集合 words 有两个单词，如今想得到[H, e, l, o, W, r, d] 在 split 方法执行完毕后，返回的是 Stream(String[]) 对象，而此时若是执行 map 方法，返回的就是多个流的集合(这个例子中就是两个 Stream(String))，这时是没法继续接下来的 distinct 操做的，所以须要 flatMap 将两个 Stream 扁平化成一个 Stream，而后进行操做

List<String> words = Arrays.asList("Hello", "World");

List<String> charList = words.stream().map(word -> word.split("")).flatMap(Arrays::stream).distinct().collect(Collectors.toList());

该方法的方法声明 flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) 中能够看出，他所使用的函数式接口 Function 第二个泛型 R 必须是 Stream 流。即函数式接口的抽象方法返回值必须是 Stream 流及其子类对象。

查找和匹配

检查谓词是否至少匹配一个元素

anyMatch 方法能够回答“流中是否存在至少一个复合谓词条件的元素”返回 boolean 类型的值，所以是一个终端操做，例如

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

if (num.stream().anyMatch(n -> n % 3 == 0)) {
    System.out.println("集合中有元素是3的整数倍");
}

控制台会输出'集合中有元素是3的整数倍',由于集合中 三、6都是3的整数倍，符合谓词的条件

检查谓词是否匹配全部元素

allMatch 方法和 anyMatch 方法原理相似，可是它仅当全部元素知足谓词条件时，返回 true。

noneMatch 与 allMatch 正好相反，仅当全部元素不知足谓词条件时，返回 true

ps:和 && || 运算符相似，以上三个操做都用到了短路的思想来提升效率。

查找元素

findAny() 该方法返回当前流中的任意元素,能够和其余流操做结合使用,这里须要注意 findAny() 返回的结果被 Optional 所包裹，Optional 是 Java8 为优雅的避免 NPE 所采用的新 API，关于 Optional 的用法我会在下一篇博客和你们讨论，敬请期待。这里须要说明的就是 Optional.ifPresent(Consumer<? super T> consumer) 表示当 Optional 包裹的元素不为空时，执行 consumer

num.stream().filter(n -> n > 2).findAny().ifPresent(System.out::println);

findFirst() 该方法返回当前流中的第一个元素,通常也和其余流操做(例如 filter() 过滤)结合使用。与 findAny() 不一样的是，他必定返回有序集合的第一个知足条件的元素。固然有得必有失，做为代价，findFirst() 在并行处理时限制更多一些。

归约

元素求和

reduce(T identity, BinaryOperator<T> accumulator); 方法接收两个参数：identity 初始值，accumulator 对两个数的操做。例如求集合中数字的和：

num.stream().reduce(0, (a, b) -> a + b) // 计算完成，返回 21

ps：Lambda 表达式 (a, b) -> a + b) 中 a 是上一轮执行完后的累计值，b 是本次循环流中的元素。经过累加就能够计算出数字的和

最大值和最小值

reduce 方法不只能够求和、求积。甚至能够计算最大值、最小值。

num.stream().reduce(Integer::max);
num.stream().reduce(Integer::min);

总结

  1. 流是 Java API 的新成员，容许程序员以声明式的方式处理集合数据，而且支持链式调用、支持并行处理。用流处理的集合数据高效且易读。
  2. 流的API中能够分为两大类，中间操做和终端操做，中间操做返回流对象，能够链式调用，终端操做则返回非流对象。
  3. 流提供了不少方便的API，如筛选 filter、去重 distinct、截断 limit、跳过 skip、函数转换 map、扁平化 flatMap、判断流中是否有任意元素符合要求 anyMatch、是否全部元素都符合要求 allMatch、是否全部元素都不符合要求 noneMatch、查找元素 findAny findFirst、累计式的计算元素 reduce

码字不易，若是你以为读完之后有收获，不妨点个推荐让更多的人看到吧！

联系我们 沪ICP备13005482号-10