Java8特性详解 lambda表达式（二）：流式处理中的lambda

要讲 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 这个函数式接口的定义如下：

@FunctionalInterface
public 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 它们两个的函数式接口定义和其中对应的方法：

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
@FunctionalInterface
public interface IntBinaryOperator {
    int applyAsInt(int left, int right);
复制代码

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

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

functionInterface 引用

自己动手实现一个例子

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

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

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

@FunctionalInterface
public 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 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 对象。

concat

连接两个 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 用法一样，只不过是求最小值。

findFirst

获取 Stream 中的第一个元素。

findAny

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

count

返回元素个数。

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。

skip

跳过前 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 方法没什么不同了。

@FunctionalInterface
public 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 方法的基础上进行封装。

mapToLong

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

mapToDouble

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

flatMap

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

1. Stream<String[]>
2. Stream<Set<String>>
3. Stream<List<String>>

以上这三类结构，通过 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 方法的基础上进行封装。

flatMapToLong

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

flatMapToDouble

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

collection

在进行了一系列操作之后，我们最终的结果大多数时候并不是为了获取 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> 类型参数。

@FunctionalInterface
public 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(){