createstreamphp技巧_8000字长文彻底理解Java8 Lambda函数式接口Stream用法和事理

就在今年 Java 25周岁了，可能比在座的各位中的一些少年年事还大，但令人遗憾的是，竟然没有我大，不禁感叹，Java 还是太小了。
（难道我会说是由于我老了？）

而就在上个月，Java 15 的试验版悄悄发布了，但是在 Java 界一贯有个神秘征象，那便是「你发你发任你发，我的最爱 Java 8」.

据 Snyk 和 The Java Magazine 联合推进身布的 2020 JVM 生态调查报告显示，在所有的 Java 版本中，仍旧有 64% 的开拓者利用 Java 8。
其余一些开拓者可能已经开始用 Java 9、Java 11、Java 13 了，当然还有一些神仙开拓者还在坚持利用 JDK 1.6 和 1.7。

只管 Java 8 发布多年，利用者浩瀚，可神奇的是竟然有很多同学没有用过 Java 8 的新特性，比如 Lambda表达式、比如方法引用，再比如本日要说的 Stream。
实在 Stream 便是以 Lambda 和方法引用为根本，封装的大略易用、函数式风格的 API。

Java 8 是在 2014 年发布的，实话说，鹞子我也是在 Java 8 发布后很长一段韶光才用的 Stream，由于 Java 8 发布的时候我还在 C# 的天下中挣扎，而利用 Lambda 表达式却很早了，由于 Python 中用 Lambda 很方便，没错，我写 Python 的韶光要比 Java 的韶光还长。

要讲 Stream ，那就不得不先说一下它的左膀右臂 Lambda 和方法引用，你用的 Stream API 实在便是函数式的编程风格，个中的「函数」便是方法引用，「式」便是 Lambda 表达式。

Lambda 表达式

Lambda 表达式是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于个中的lambda抽象，是一个匿名函数，即没有函数名的函数。
Lambda表达式可以表示闭包。

在 Java 中，Lambda 表达式的格式是像下面这样

// 无参数，无返回值() -> log.info("Lambda") // 有参数，有返回值(int a, int b) -> { a+b }

其等价于

log.info("Lambda");private int plus(int a, int b){ return a+b;}

最常见的一个例子便是新建线程，有时候为了省事，会用下面的方法创建并启动一个线程，这是匿名内部类的写法，new Thread须要一个 implements 自Runnable类型的工具实例作为参数，比较好的办法是创建一个新类，这个类 implements Runnable，然后 new 出这个新类的实例作为参数传给 Thread。
而匿名内部类不用找工具吸收，直接当做参数。

new Thread(new Runnable() { @Override public void run() { System.out.println("快速新建并启动一个线程"); }}).start();

但是这样写是不是觉得看上去很乱、很土，而这时候，换上 Lambda 表达式便是其余一种觉得了。

new Thread(()->{ System.out.println("快速新建并启动一个线程");}).start();

怎么样，这样一改，瞬间觉得清新脱俗了不少，简洁优雅了不少。

Lambda 表达式简化了匿名内部类的形式，可以达到同样的效果，但是 Lambda 要优雅的多。
虽然终极达到的目的是一样的，但实在内部的实现事理却不相同。

匿名内部类在编译之后会创建一个新的匿名内部类出来，而 Lambda 是调用 JVM invokedynamic指令实现的，并不会产生新类。

方法引用的涌现，使得我们可以将一个方法赋给一个变量或者作为参数通报给其余一个方法。
::双冒号作为方法引用的符号，比如下面这两行语句，引用 Integer类的 parseInt方法。

Function<String, Integer> s = Integer::parseInt;Integer i = s.apply("10");

或者下面这两行，引用 Integer类的 compare方法。

Comparator<Integer> comparator = Integer::compare;int result = comparator.compare(100,10);

再比如，下面这两行代码，同样是引用 Integer类的 compare方法，但是返回类型却不一样，但却都能正常实行，并精确返回。

IntBinaryOperator intBinaryOperator = Integer::compare;int result = intBinaryOperator.applyAsInt(10,100);

相信有的同学看到这里恐怕是下面这个状态，完备不可理喻吗，也太随便了吧，返回给谁都能接盘。

先别激动，来来来，现在咱们就来解惑，解除蒙圈脸。

Q：什么样的方法可以被引用？

A：这么说吧，任何你有办法访问到的方法都可以被引用。

Q：返回值到底是什么类型？

A：这就问到点儿上了，上面又是 Function、又是Comparator、又是 IntBinaryOperator的，看上去彷佛没有规律，实在不然。

返回的类型是 Java 8 专门定义的函数式接口，这类接口用 @FunctionalInterface 表明。

比如 Function这个函数式接口的定义如下：

@FunctionalInterfacepublic interface Function<T, R> { R apply(T t);}

还有很关键的一点，你的引用方法的参数个数、类型，返回值类型要和函数式接口中的方法声明逐一对应才行。

比如 Integer.parseInt方法定义如下：

public static int parseInt(String s) throws NumberFormatException { return parseInt(s,10);}

首先parseInt方法的参数个数是 1 个，而 Function中的 apply方法参数个数也是 1 个，参数个数对应上了，再来，apply方法的参数类型和返回类型是泛型类型，以是肯定能和 parseInt方法对应上。

这样一来，就可以精确的吸收Integer::parseInt的方法引用，并可以调用Funciton的apply方法，这时候，调用到的实在便是对应的 Integer.parseInt方法了。

用这套标准套到 Integer::compare方法上，就不难明得为什么即可以用 Comparator<Integer>吸收，又可以用 IntBinaryOperator吸收了，而且调用它们各自的方法都能精确的返回结果。

Integer.compare方法定义如下：

public static int compare(int x, int y) { return (x < y) ? -1 : ((x == y) ? 0 : 1);}

返回值类型 int，两个参数，并且参数类型都是 int。

然后来看Comparator和IntBinaryOperator它们两个的函数式接口定义和个中对应的方法：

@FunctionalInterfacepublic interface Comparator<T> { int compare(T o1, T o2);}@FunctionalInterfacepublic interface IntBinaryOperator { int applyAsInt(int left, int right);}

对不对，都能精确的匹配上，以是前面示例中用这两个函数式接口都能正常吸收。
实在不止这两个，只假如在某个函数式接口中声明了这样的方法：两个参数，参数类型是 int或者泛型，并且返回值是 int或者泛型的，都可以完美吸收。

JDK 中定义了很多函数式接口，紧张在 java.util.function包下，还有 java.util.Comparator 专门用作定制比较器。
其余，前面说的 Runnable也是一个函数式接口。

自己动手实现一个例子

1. 定义一个函数式接口，并添加一个方法

定义了名称为 KiteFunction 的函数式接口，利用 @FunctionalInterface表明，然后声明了具有两个参数的方法 run，都是泛型类型，返回结果也是泛型。

还有一点很主要，函数式接口中只能声明一个可被实现的方法，你不能声明了一个 run方法，又声明一个 start方法，到时候编译器就不知道用哪个吸收了。
而用default 关键字润色的方法则没有影响。

@FunctionalInterfacepublic interface KiteFunction<T, R, S> { / 定义一个双参数的方法 @param t @param s @return / R run(T t,S s);}

2. 定义一个与 KiteFunction 中 run 方法对应的方法

在 FunctionTest 类中定义了方法 DateFormat，一个将 LocalDateTime类型格式化为字符串类型的方法。

public class FunctionTest { public static String DateFormat(LocalDateTime dateTime, String partten) { DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(partten); return dateTime.format(dateTimeFormatter); }}

3.用方法引用的办法调用

正常情形下我们直策应用 FunctionTest.DateFormat()就可以了。

而用函数式办法，是这样的。

KiteFunction<LocalDateTime,String,String> functionDateFormat = FunctionTest::DateFormat;String dateString = functionDateFormat.run(LocalDateTime.now(),"yyyy-MM-dd HH:mm:ss");

而实在我可以不专门在表面定义 DateFormat这个方法，而是像下面这样，利用匿名内部类。

public static void main(String[] args) throws Exception { String dateString = new KiteFunction<LocalDateTime, String, String>() { @Override public String run(LocalDateTime localDateTime, String s) { DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(s); return localDateTime.format(dateTimeFormatter); } }.run(LocalDateTime.now(), "yyyy-MM-dd HH:mm:ss"); System.out.println(dateString);}

前面第一个 Runnable的例子也提到了，这样的匿名内部类可以用 Lambda 表达式的形式简写，简写后的代码如下：

public static void main(String[] args) throws Exception { KiteFunction<LocalDateTime, String, String> functionDateFormat = (LocalDateTime dateTime, String partten) -> { DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(partten); return dateTime.format(dateTimeFormatter); }; String dateString = functionDateFormat.run(LocalDateTime.now(), "yyyy-MM-dd HH:mm:ss"); System.out.println(dateString);}

利用（LocalDateTime dateTime, String partten) -> { } 这样的 Lambda 表达式直接返回方法引用。

为了说一下 Stream API 的利用，可以说是大费周章啊，知其然，也要知其以是然吗，追求技能的态度和姿势要精确。

当然 Stream 也不但是 Lambda 表达式就厉害了，真正厉害的还是它的功能，Stream 是 Java 8 中凑集数据处理的利器，很多本来繁芜、须要写很多代码的方法，比如过滤、分组等操作，每每利用 Stream 就可以在一行代码搞定，当然也由于 Stream 都是链式操作，一行代码可能会调用好几个方法。

Collection接供词给了 stream()方法，让我们可以在一个凑集方便的利用 Stream API 来进行各种操作。
值得把稳的是，我们实行的任何操作都不会对源凑集造成影响，你可以同时在一个凑集上提取出多个 stream 进行操作。

我们看 Stream 接口的定义，继续自 BaseStream，机会所有的接口声明都是吸收方法引用类型的参数，比如 filter方法，吸收了一个 Predicate类型的参数，它便是一个函数式接口，常用来作为条件比较、筛选、过滤用，JPA中也利用了这个函数式接口用来做查询条件拼接。

public interface Stream<T> extends BaseStream<T, Stream<T>> { Stream<T> filter(Predicate<? super T> predicate); // 其他接口}

下面就来看看 Stream 常用 API。

of

可吸收一个泛型工具或可变成泛型凑集，布局一个 Stream 工具。

private static void createStream(){ Stream<String> stringStream = Stream.of("a","b","c");}empty

创建一个空的 Stream 工具。

连接两个 Stream ，不改变个中任何一个 Steam 工具，返回一个新的 Stream 工具。

private static void concatStream(){ Stream<String> a = Stream.of("a","b","c"); Stream<String> b = Stream.of("d","e"); Stream<String> c = Stream.concat(a,b);}max

一样平常用于求数字凑集中的最大值，或者按实体中数字类型的属性比较，拥有最大值的那个实体。
它吸收一个 Comparator<T>，上面也举到这个例子了，它是一个函数式接口类型，专门用作定义两个工具之间的比较，例如下面这个方法利用了 Integer::compareTo这个方法引用。

private static void max(){ Stream<Integer> integerStream = Stream.of(2, 2, 100, 5); Integer max = integerStream.max(Integer::compareTo).get(); System.out.println(max);}

当然，我们也可以自己定制一个 Comparator，顺便复习一下 Lambda 表达式形式的方法引用。

private static void max(){ Stream<Integer> integerStream = Stream.of(2, 2, 100, 5); Comparator<Integer> comparator = (x, y) -> (x.intValue() < y.intValue()) ? -1 : ((x.equals(y)) ? 0 : 1); Integer max = integerStream.max(comparator).get(); System.out.println(max);}min

与 max 用法一样，只不过是求最小值。

获取 Stream 中的第一个元素。

获取 Stream 中的某个元素，如果是串行情形下，一样平常都会返回第一个元素，并行情形下就不一定了。

返回元素个数。

Stream<String> a = Stream.of("a", "b", "c");long x = a.count();peek

建立一个通道，在这个通道中对 Stream 的每个元素实行对应的操作，对应 Consumer<T>的函数式接口，这是一个消费者函数式接口，顾名思义，它是用来消费 Stream 元素的，比如下面这个方法，把每个元素转换成对应的大写字母并输出。

private static void peek() { Stream<String> a = Stream.of("a", "b", "c"); List<String> list = a.peek(e->System.out.println(e.toUpperCase())).collect(Collectors.toList());}forEach

和 peek 方法类似，都吸收一个消费者函数式接口，可以对每个元素进行对应的操作，但是和 peek 不同的是，forEach 实行之后，这个 Stream 就真的被消费掉了，之后这个 Stream 流就没有了，不可以再对它进行后续操作了，而 peek操作完之后，还是一个可操作的 Stream 工具。

恰好借着这个说一下，我们在利用 Stream API 的时候，都是一串链式操作，这是由于很多方法，比如接下来要说到的 filter方法等，返回值还是这个 Stream 类型的，也便是被当前方法处理过的 Stream 工具，以是 Stream API 仍旧可以利用。

private static void forEach() { Stream<String> a = Stream.of("a", "b", "c"); a.forEach(e->System.out.println(e.toUpperCase()));}forEachOrdered

功能与 forEach是一样的，不同的是，forEachOrdered是有顺序担保的，也便是对 Stream 中元素按插入时的顺序进行消费。
为什么这么说呢，当开启并行的时候，forEach和 forEachOrdered的效果就不一样了。

Stream<String> a = Stream.of("a", "b", "c");a.parallel().forEach(e->System.out.println(e.toUpperCase()));

当利用上面的代码时，输出的结果可能是 B、A、C 或者 A、C、B或者A、B、C，而利用下面的代码，则每次都是 A、 B、C

Stream<String> a = Stream.of("a", "b", "c");a.parallel().forEachOrdered(e->System.out.println(e.toUpperCase()));limit

获取前 n 条数据，类似于 MySQL 的limit，只不过只能吸收一个参数，便是数据条数。

private static void limit() { Stream<String> a = Stream.of("a", "b", "c"); a.limit(2).forEach(e->System.out.println(e));}

上述代码打印的结果是 a、b。

跳过前 n 条数据，例如下面代码，返回结果是 c。

private static void skip() { Stream<String> a = Stream.of("a", "b", "c"); a.skip(2).forEach(e->System.out.println(e));}distinct

元素去重，例如下面方法返回元素是 a、b、c，将重复的 b 只保留了一个。

private static void distinct() { Stream<String> a = Stream.of("a", "b", "c","b"); a.distinct().forEach(e->System.out.println(e));}sorted

有两个重载，一个无参数，其余一个有个 Comparator类型的参数。

无参类型的按照自然顺序进行排序，只适宜比较纯挚的元素，比如数字、字母等。

private static void sorted() { Stream<String> a = Stream.of("a", "c", "b"); a.sorted().forEach(e->System.out.println(e));}

有参数的须要自定义排序规则，例如下面这个方法，按照第二个字母的大小顺序排序，末了输出的结果是 a1、b3、c6。

private static void sortedWithComparator() { Stream<String> a = Stream.of("a1", "c6", "b3"); a.sorted((x,y)->Integer.parseInt(x.substring(1))>Integer.parseInt(y.substring(1))?1:-1).forEach(e->System.out.println(e));}

为了更好的解释接下来的几个 API ，我仿照了几条项目中常常用到的类似数据，10条用户信息。

private static List<User> getUserData() { Random random = new Random(); List<User> users = new ArrayList<>(); for (int i = 1; i <= 10; i++) { User user = new User(); user.setUserId(i); user.setUserName(String.format("古时的鹞子 %s 号", i)); user.setAge(random.nextInt(100)); user.setGender(i % 2); user.setPhone("18812021111"); user.setAddress("无"); users.add(user); } return users;}filter

用于条件筛选过滤，筛选出符合条件的数据。
例如下面这个方法，筛选出性别为 0，年事大于 50 的记录。

private static void filter(){ List<User> users = getUserData(); Stream<User> stream = users.stream(); stream.filter(user -> user.getGender().equals(0) && user.getAge()>50).forEach(e->System.out.println(e)); / 等同于下面这种形式 匿名内部类 /// stream.filter(new Predicate<User>() {// @Override// public boolean test(User user) {// return user.getGender().equals(0) && user.getAge()>50;// }// }).forEach(e->System.out.println(e));}map

map方法的接口方法声明如下，接管一个 Function函数式接口，把它翻译成映射最得当了，通过原始数据元素，映射出新的类型。

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

而 Function的声明是这样的，不雅观察 apply方法，接管一个 T 型参数，返回一个 R 型参数。
用于将一个类型转换成其余一个类型正得当，这也是 map的初衷所在，用于改变当前元素的类型，例如将 Integer 转为 String类型，将 DAO 实体类型，转换为 DTO 实例类型。

当然了，T 和 R 的类型也可以一样，这样的话，就和 peek方法没什么不同了。

@FunctionalInterfacepublic interface Function<T, R> { / Applies this function to the given argument. @param t the function argument @return the function result / R apply(T t);}

例如下面这个方法，该当是业务系统的常用需求，将 User 转换为 API 输出的数据格式。

private static void map(){ List<User> users = getUserData(); Stream<User> stream = users.stream(); List<UserDto> userDtos = stream.map(user -> dao2Dto(user)).collect(Collectors.toList());}private static UserDto dao2Dto(User user){ UserDto dto = new UserDto(); BeanUtils.copyProperties(user, dto); //其他额外处理 return dto;}mapToInt

将元素转换成 int 类型，在 map方法的根本上进行封装。

将元素转换成 Long 类型，在 map方法的根本上进行封装。

将元素转换成 Double 类型，在 map方法的根本上进行封装。

这是用在一些比较特殊的场景下，当你的 Stream 因此下这几种构造的时候，须要用到 flatMap方法，用于将原有二维构造扁平化。

以上这三类构造，通过 flatMap方法，可以将结果转化为 Stream<String>这种形式，方便之后的其他操作。

比如下面这个方法，将List<List<User>>扁平处理，然后再利用 map或其他方法进行操作。

private static void flatMap(){ List<User> users = getUserData(); List<User> users1 = getUserData(); List<List<User>> userList = new ArrayList<>(); userList.add(users); userList.add(users1); Stream<List<User>> stream = userList.stream(); List<UserDto> userDtos = stream.flatMap(subUserList->subUserList.stream()).map(user -> dao2Dto(user)).collect(Collectors.toList());}flatMapToInt

用法参考 flatMap，将元素扁平为 int 类型，在 flatMap方法的根本上进行封装。

用法参考 flatMap，将元素扁平为 Long 类型，在 flatMap方法的根本上进行封装。

用法参考 flatMap，将元素扁平为 Double 类型，在 flatMap方法的根本上进行封装。

在进行了一系列操作之后，我们终极的结果大多数时候并不是为了获取 Stream 类型的数据，而是要把结果变为 List、Map 这样的常用数据构造，而 collection便是为了实现这个目的。

就拿 map 方法的那个例子解释，将工具类型进行转换后，终极我们须要的结果集是一个 List<UserDto >类型的，利用 collect方法将 Stream 转换为我们须要的类型。

下面是 collect接口方法的定义：

<R, A> R collect(Collector<? super T, A, R> collector);

下面这个例子演示了将一个大略的 Integer Stream 过滤出大于 7 的值，然后转换成 List<Integer>凑集，用的是 Collectors.toList()这个网络器。

private static void collect(){ Stream<Integer> integerStream = Stream.of(1,2,5,7,8,12,33); List<Integer> list = integerStream.filter(s -> s.intValue()>7).collect(Collectors.toList());}

很多同学表示看不太懂这个 Collector是怎么一个意思，来，我们看下面这段代码，这是 collect的另一个重载方法，你可以理解为它的参数是按顺序实行的，这样就清楚了，这便是个 ArrayList 从创建到调用 addAll方法的一个过程。

private static void collect(){ Stream<Integer> integerStream = Stream.of(1,2,5,7,8,12,33); List<Integer> list = integerStream.filter(s -> s.intValue()>7).collect(ArrayList::new, ArrayList::add, ArrayList::addAll);}

我们在自定义 Collector的时候实在也是这个逻辑，不过我们根本不用自定义， Collectors已经为我们供应了很多拿来即用的网络器。
比如我们常常用到Collectors.toList()、Collectors.toSet()、Collectors.toMap()。
其余还有比如Collectors.groupingBy()用来分组，比如下面这个例子，按照 userId 字段分组，返回以 userId 为key，List 为value 的 Map，或者返回每个 key 的个数。

// 返回 userId:List<User>Map<String,List<User>> map = user.stream().collect(Collectors.groupingBy(User::getUserId));// 返回 userId:每组个数Map<String,Long> map = user.stream().collect(Collectors.groupingBy(User::getUserId,Collectors.counting()));toArray

collection是返回列表、map 等，toArray是返回数组，有两个重载，一个空参数，返回的是 Object[]。

另一个吸收一个 IntFunction<R>类型参数。

@FunctionalInterfacepublic interface IntFunction<R> { / Applies this function to the given argument. @param value the function argument @return the function result / R apply(int value);}

比如像下面这样利用，参数是 User[]::new也便是new 一个 User 数组，长度为末了的 Stream 长度。

private static void toArray() { List<User> users = getUserData(); Stream<User> stream = users.stream(); User[] userArray = stream.filter(user -> user.getGender().equals(0) && user.getAge() > 50).toArray(User[]::new);}reduce

它的浸染是每次打算的时候都用到上一次的打算结果，比如求和操作，前两个数的和加上第三个数的和，再加上第四个数，一贯加到末了一个数位置，末了返回结果，便是 reduce的事情过程。

private static void reduce(){ Stream<Integer> integerStream = Stream.of(1,2,5,7,8,12,33); Integer sum = integerStream.reduce(0,(x,y)->x+y); System.out.println(sum);}

其余 Collectors好多方法都用到了 reduce，比如 groupingBy、minBy、maxBy等等。

Stream 实质上来说便是用来做数据处理的，为了加快处理速率，Stream API 供应了并行处理 Stream 的办法。
通过 users.parallelStream()或者users.stream().parallel() 的办法来创建并行 Stream 工具，支持的 API 和普通 Stream 险些是同等的。

并行 Stream 默认利用 ForkJoinPool线程池，当然也支持自定义，不过一样平常情形下没有必要。
ForkJoin 框架的分治策略与并行流处理恰好契合。

虽然并行这个词听上去很厉害，但并不是所有情形利用并行流都是精确的，很多时候完备没这个必要。

什么情形下利用或不应利用并行流操作呢？

Java 25 周岁了，有多少同学跟我一样在用 Java 8，还有多少同学再用更早的版本，请说出你的故事。

来源：掘金 链接：https://juejin.im/post/5ee035e4f265da76c67ca979