Java8新特性 Lambda&函数接口&Stream

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

Lambda 表达式

@Test
    public void test1() {
        I1 i1 = new I1() {
            @Override
            public void test1() {
                System.out.println("这是内部类的test1"); }
        };
        i1.test1();
        I1 i2 = () -> {
            System.out.println("Lambda的test1....");
        };
        i2.test1();

        I1 i3 = () -> System.out.println("Lambada的test1----精简化");
        i3.test1();
        
        //类型推断
        List<Integer> integers = new ArrayList<>();
    }
}

 @Test
    public void test2() {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add((int)(Math.random()*50));
        }
        Comparator<Integer> comparator1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        };
        Collections.sort(list,comparator1);
        Collections.shuffle(list);
        //Comparator<Integer> comparator2 = (o1, o2) -> o2 - o1;
        Collections.sort(list,(o1, o2) -> o2 -o1);
    }

Lambda 表达式语法

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：

左侧：指定了 Lambda 表达式需要的参数列表

右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能

语法格式一：无参，无返回值

I1 i3 = () -> System.out.println("Lambada的test1----精简化");

语法格式二：Lambda 需要一个参数，但是没有返回值

IA ia1 = (String string)  ->  Integer.parseInt(string) ;

语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

IA ia1 = （s） -> Integer.parseInt(s);

语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略

IA ia1 = s -> Integer.parseInt(s);

语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值

Comparator<Integer> comparator2 = (Integer o1, Integer o2) -> {return o2 - o1;};

语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略

Comparator<Integer> comparator2 = (o1, o2) -> o2 - o1;

类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”。

函数式(Functional)接口

只包含一个抽象方法的接口，称为函数式接口。
你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常(即：非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。
我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
在java.util.function包下定义了java 8 的丰富的函数式接口

Java 内置四大核心函数式接口

函数式接口	参数类型	返回类型	用途
Consumer<T> 消费型接口	T	void	对类型为T的对象应用操作，包含方法： void accept(T t)
Supplier<T> 供给型接口	无	T	返回类型为T的对象，包含方法：T get()
Function<T, R> 函数型接口	T	R	对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t)
Predicate<T> 断定型接口	T	boolean	确定类型为T的对象是否满足某约束，并返回 boolean 值。包含方法 boolean test(T t)

 函数式接口
* 只有一个抽象方法的接口, 可以用@FunctionalInterface修饰
* <p>
* Consumer<T> 消费器, 作用是消费一个T类型的对象, 并没有返回.
* void accept(T t) : 有输入无输出
* <p>
* Supplier<T> 供给器, 作用是供给一个T类型的对象, 不需要参数.
* T get() : 无输入有输出
* <p>
* Function<T, R> 转换器, 作用是输入一个T类型对象, 经过处理, 返回的是R类型对象.
* R apply(T t) : 有输入有输出
* <p>
* Predicate<T> 判定器, 作用是输入一个T类型对象, 经过某种判断, 返回true或false
* boolean test(T t) : 有输入有固定输出布尔
* <p>

其他接口

函数式接口	参数类型	返回类型	用途
BiFunction<T, U, R>	T, U	R	对类型为 T, U 参数应用操作，返回 R 类型的结果。包含方法为   R apply(T t, U u);
UnaryOperator<T> (Function子接口)	T	T	对类型为T的对象进行一元运算，并返回T类型的结果。包含方法为  T apply(T t);
BinaryOperator<T> (BiFunction 子接口)	T, T	T	对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为   T apply(T t1, T t2);
BiConsumer<T, U>	T, U	void	对类型为T, U 参数应用操作。包含方法为  void accept(T t, U u)
BiPredicate<T,U>