Lambda表达式

面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。

本质是匿名内部类的简化书写格式

标准格式

• 一些参数
• 一个箭头
• 一段代码

Lambda表达式的标准格式为：

(参数类型 参数名称) -> { 代码语句 }

格式说明

• 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
• -> 是新引入的语法格式，代表指向动作。
• 大括号内的语法与传统方法体要求基本一致。

省略格式

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
   备注：掌握这些省略规则后，请对应地回顾本章开头的多线程案例。
   可推导即可省略

Lambda的前提条件

1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
   无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一
   时，才可以使用Lambda。
2. 使用Lambda必须具有接口作为方法参数。
   也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注

有且仅有一个抽象方法的接口，称为“函数式接口”。

函数式接口

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可
以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注:

从应用层面来讲，Java中的Lambda可以看做是匿名内部类的简化格式，但是二者在原理上不同。

格式

只要确保接口中有且仅有一个抽象方法即可：

修饰符 interface 接口名称 {
    public abstract 返回值类型 方法名称(可选参数信息);
    // 其他非抽象方法内容
}

由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单：

public interface MyFunctionalInterface {
    void myMethod();
}

自定义函数式接口

对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：

public class Demo07FunctionalInterface {
    // 使用自定义的函数式接口作为方法参数
    private static void doSomething(MyFunctionalInterface inter) {
    inter.myMethod(); // 调用自定义的函数式接口方法
    }
public static void main(String[] args) {
    // 调用使用函数式接口的方法
    doSomething(() -> System.out.println("Lambda执行啦！"));
    }
}

FunctionalInterface注解

与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。该注
解可用于一个接口的定义上：

@FunctionalInterface
public interface MyFunctionalInterface {
    void myMethod();
}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。不过，
即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

常用函数式接口

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。

Consumer接口

java.util.function.Consumer<T> 接口，是消费一个数据，其数据类型由泛型参数决定。

抽象方法

accept：Consumer 接口中包含抽象方法 void accept(T t) : 消费一个指定泛型的数据

//给你一个字符串,请按照大写的方式进行消费
import java.util.function.Consumer;
public class Demo08Consumer {
public static void main(String[] args) {
    String str = "Hello World";
    //1.lambda表达式标准格式
    fun(str,(String s)->{
    System.out.println(s.toUpperCase());
    });
    //2.lambda表达式简化格式

    fun(str,s-> System.out.println(s.toUpperCase()));
    }
    /*
    定义方法,使用Consumer接口作为参数
    fun方法: 消费一个String类型的变量
    */
    public static void fun(String s,Consumer<String> con) {
    con.accept(s);
    }
}

Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T> 接口。

抽象方法：test

Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景：

//1.练习:判断字符串长度是否大于5
//2.练习:判断字符串是否包含"H"
public class Demo09Predicate {
    private static void method(Predicate<String> predicate,String str) {
        boolean veryLong = predicate.test(str);
        System.out.println("字符串很长吗：" + veryLong);
    }
    public static void main(String[] args) {
        method(s -> s.length() > 5, "HelloWorld");
    }
}

条件判断的标准是传入的Lambda表达式逻辑，只要字符串长度大于5则认为很长。总结来说，就是用这个接口作为方法的一个参数，用lambda表达式可以直接将接口中的方法实现。

Stream流

在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的
弊端。

获取流方式

java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口。

获取一个流非常简单，有以下几种常用的方式：

• 所有的 Collection 集合都可以通过 stream 默认方法获取流；
• Stream 接口的静态方法 of 可以获取数组对应的流。

方式1 : 根据Collection获取流

首先， java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流。

java.util.Collection 接口

    默认方法: 必须由Collection接口的实现类(ArrayList/LinkedList/HashSet/LinkedHashSet)对象调用
        public default Stream<T> stream(): 获取Collection集合对象对应的Stream流对象

方式2: 根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法of

java.util.stream.Stream 接口:

    静态方法
    public static <T> Stream<T> of(T ... t): 把方法的可变参数指定的具体数据,转换成Stream流对象
        参数:
            T ... t: 可变参数   传递数组,参数列表,不传递

public class Demo05GetStream {
    public static void main(String[] args) {
        //获取List集合的Stream对象
        List<String> list = new ArrayList<>();
        Stream<String> s1 = list.stream();
        System.out.println(s1);

        //获取Set集合的Stream对象
        Set<Integer> set = new HashSet<>();
        Stream<Integer> s2 = set.stream();
        System.out.println(s2);

        Map<String,String> map = new HashMap<>();

        //Map键的Set集合
        Set<String> set2 = map.keySet();
        Stream<String> s3 = set2.stream();
        System.out.println(s3);

        //Map值的Collection集合
        Collection<String> coll = map.values();
        Stream<String> s4 = coll.stream();
        System.out.println(s4);

        //Map键值对的Set集合
        Set<Map.Entry<String, String>> set3 = map.entrySet();
        Stream<Map.Entry<String, String>> s5 = set3.stream();
        System.out.println(s5);
        System.out.println("----------");
        String[] arr = {"Hello","World","java"};
        Stream<String> s6 = Stream.of(arr);
        System.out.println(s6);

        Stream<String> s7 = Stream.of("Hello", "World", "java");
        System.out.println(s7);

    }
}

备注： of 方法的参数其实是一个可变参数，所以支持数组。

常用方法

流模型的操作很丰富，下面是一些常用的API。这些方法可以被分成两种：

• 终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调
  用。本小节中，终结方法包括 count 和 forEach 方法。
• 非终结方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余
  方法均为非终结方法。）

forEach : 逐一处理

虽然方法名字叫 forEach ，但是与for循环中的“for-each”昵称不同，该方法并不保证元素的逐一消费动作在流中是
被有序执行的。

void forEach(Consumer<? super T> action);

该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。例如：

import java.util.stream.Stream;
public class Demo15StreamForEach {
public static void main(String[] args) {
    Stream<String> stream = Stream.of("大娃","二娃","三娃","四娃","五娃","六娃","七娃","爷
    爷","蛇精","蝎子精");
    //Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
    stream.forEach((String str)->{System.out.println(str);});
    }
}

注意，上方代码注释的原因是stream流只能被使用一次，不能循环使用

filter：过滤

可以通过 filter 方法将一个流转换成另一个子集流。方法声明：

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda）作为筛选条件。

基本使用

Stream流中的 filter 方法基本使用的代码如：

public class Demo16StreamFilter {
public static void main(String[] args) {
    Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
    Stream<String> result = original.filter((String s) -> {return s.startsWith("张");});
    }
}

count：统计个数

正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：

public class Demo16StreamFilter {
public static void main(String[] args) {
    Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
    Stream<String> result = original.filter((String s) -> {return s.startsWith("张");});
    System.out.println(result.count()); // 2
    }
}

limit：取用前几个

limit 方法可以对流进行截取，只取用前n个。

Stream<T> limit(long maxSize):获取Stream流对象中的前n个元素,返回一个新的Stream流对象

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。

import java.util.stream.Stream;
public class Demo18StreamLimit {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.limit(2);
        System.out.println(result.count()); // 2
    }
}

skip：跳过前几个

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流

Stream<T> skip(long n): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。基本使用：

import java.util.stream.Stream;
public class Demo19StreamSkip {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.skip(2);
        System.out.println(result.count()); // 1
    }
}

concat：组合

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b): 把参数列表中的两个
Stream流对象a和b,合并成一个新的Stream流对象

备注：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。

该方法的基本使用代码如：

import java.util.stream.Stream;
public class Demo20StreamConcat {
    public static void main(String[] args) {
        Stream<String> streamA = Stream.of("张无忌");
        Stream<String> streamB = Stream.of("张翠山");
        Stream<String> result = Stream.concat(streamA, streamB);
    }
}