一、Lambda表达式

• 举例：(o1,o2) -> Interger.compare(o1,o2);
• 格式：
  • -> : lambda操作符 或 箭头表达式
  • ->左边 ：lambda形参列表（其实就是接口中的抽象方法的形参列表）
  • ->右边 : lambda体（其实就是重写的抽象方法的方法体）
• lambda表达式的本质：作为函数式接口的实例
• 总结：
  • ->左边：
    • lambda形参列表的参数类型可以省略（类型推断）；
    • 如果lambda形参列表只有一个参数，其一对()也可以省略
  • ->右边：
    • lambda应该使用一对{}包裹；
    • 如果lambda体只有一条执行语句（可能是return语句），可以省略这一对{}和return关键字

import java.util.Comparator;
import java.util.function.Consumer;

public class LambdaTest {
    public static void main(String[] args) {

        //语法格式一：无参，无返回值
        Runnable r1 = () -> {
            System.out.println("我爱中华!");
        };
        r1.run();

        //语法格式二：Lambda需要一个参数，但是没有返回值
        Consumer consumer1 = (String str) -> {
            System.out.println(str);
        };
        consumer1.accept("谎言和誓言的区别是什么呢?");

        //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
        Consumer consumer2 = (str) -> System.out.println(str);
        consumer2.accept("一个是听的人当真了，一个是说的人当真了。");

        //语法格式四：Lambda若只需要一个参数，参数的小括号可以省略
        Consumer consumer3 = str -> System.out.println(str);
        consumer3.accept("花开花落几时回？");

        //语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值
        Comparator comparator1 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(comparator1.compare(12, 21));

        //语法格式六：当Lambda体只有一条执行语句时，return 与大括号若有，都可以省略
        Comparator comparator2 = (o1,o2) -> o1.compareTo(o2);
        System.out.println(comparator2.compare(12, 6));

    }
}

二、函数式（Functional）接口

??如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。可以通过Lambda表达式来创建该接口的对象。若Lambda表达式抛出一个受检异常（即：非运行时异常），那么该异常需要在目标接口的抽象方法上进行声明。可以通过在一个接口上使用@FunctionalInterface注解，这样可以检查它是否是一个函数时接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。匿名实现类表示都可以用Lambda表达式来写。

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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class FunctionalInterface {
    public static void main(String[] args) {
        FunctionalInterface test = new FunctionalInterface();
        List list = Arrays.asList("北京","天津","南京","西京","东京","开封");

        test.happyTime(400,money -> System.out.println("今天共消费" + money));
        List string =  test.filterString(list,str -> str.contains("京"));
        System.out.println(string);
    }

    public void happyTime(double money,Consumer consumer){
        consumer.accept(money);
    }

    //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List filterString(List list,Predicate predicate){
        ArrayList filterList = new ArrayList<>();

        for (String str : list) {
            if(predicate.test(str)){
                filterList.add(str);
            }
        }

        return filterList;
    }
}

2.2、其它接口

三、方法引用与构造器引用

3.1、方法引用

??当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用。方法引用可以看做是Lambda表达式的深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法。方法引用要求实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！（针对情况一和情况二）格式：使用操作符“::”将类（或对象）与方法名分隔开来。当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数（或无参数）时，（针对情况三）格式：ClassName::methodName

如下三种主要使用情况

• 情况一：对象::实例方法名
• 情况二：类::静态方法名
• 情况三：类::实例方法名

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class MethodReference {
    public static void main(String[] args) {

        //情况一：对象::实例方法
        //Consumer中的 void accept(T t)
        //PrintStream中的 void println(T t)
        PrintStream printStream = System.out;
        Consumer consumer = printStream::println;
        consumer.accept("Sakura");

        //情况二：类::静态方法
        //Supplier中的 T get()
        //Person中的 String gerName() 
        Person person = new Person("Sakura",10);
        Supplier supplier = person::getAge;
        System.out.println(supplier.get());

        //情况三：类::非静态方法
        //Comparator中的 int compare(T t1,T t2)
        //Integer中的 int compare(T t1,T t2)
        Comparator comparator = Integer::compare;
        System.out.println(comparator.compare(10, 13));

        System.out.println();

        //Function中的 R apply(T t)
        //Math中的 Long round(Double d)
        Function fun1 = new Function() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        }; 
        System.out.println(fun1.apply(12.3));

        Function fun2 = d -> Math.round(d);
        System.out.println(fun2.apply(21.5));

        Function fun3 = Math::round;
        System.out.println(fun3.apply(33.7));

        System.out.println();

        //Comparator中的 int comapre(T t1,T t2)
        //String中的 int t1.comparaTo(t2)
        Comparator comparator2 = String::compareTo;
        System.out.println(comparator2.compare("intel", "amd"));

        //Function中的 R apply(T t)
        //Person中的 String getName()
        Function fun4 = Person::getName;
        System.out.println(fun4.apply(person));
    }
}

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public Person(String name, int age) {
        this(name);
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String toString(){
        return "Person{ name:" + name + ",age:" + age + "}";
    }
}

3.2、构造器引用

??构造器引用与方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型。

import java.util.function.Function;
import java.util.function.Supplier;

public class ConstructorReference {
    public static void main(String[] args) {

        //Supplier中的 T get()
        Supplier supplier = Person::new;
        System.out.println(supplier.get());

        //Function中的 R apply(T t)
        Function fun = Person::new;
        System.out.println(fun.apply("Sakura"));

        //BiFunction中 R apply(T t,U u)
        BiFunction biFunction = Person::new;
        System.out.println(biFunction.apply("Sakura", 9));
    }
}

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public Person(String name, int age) {
        this(name);
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String toString(){
        return "Person{ name:" + name + ",age:" + age + "}";
    }
}

3.3、数组引用

??可以把数组看做是一个特殊的类，则写法与构造器引用一致；

import java.util.Arrays;
import java.util.function.Function;

public class ArrayReferences {
    public static void main(String[] args) {

        Function fun1 = length -> new String[length];
        String[] array1 = fun1.apply(5);
        System.out.println(Arrays.toString(array1));

        Function fun2 = String[]::new;
        String[] array2 = fun2.apply(10);
        System.out.println(Arrays.toString(array2));
    }
}

四、强大的Stream API

4.1 Stream概述

??Stream API(java.util.stream)把真正的函数式接口编程风格引入到Java中。Stream是Java 8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简言之，Stream API提供了一种高效且易于使用的处理数据的方式。

• Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列
• Stream自己不会存储元素
• Stream不会改变源对象。相反，它会返回一个持有结果的新Stream
• Stream操作是延迟执行的。这意味着它会等到需要结果的时候才执行

创建Stream的操作三个对象

1. 创建Stream：一个数据源（如：集合、数组），获取一个流
2. 中间操作：一个中间操作链，对数据源的数据进行处理
3. 终止操作（终端操作）：一旦执行终止操作，就会执行中间操作链，并产生结果。之后，不会再被使用

4.2、创建Stream

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {

        //创建Stream方式一：通过集合
        List list = Arrays.asList(1,2,3,4,5);

        //default Stream stream()：返回一个顺序流
        Stream stream = list.stream();
        //default Stream parallelStream()：返回一个并行流
        Stream parallelStream = list.parallelStream();

        //创建Stream方式二：通过数组
        Object[] object = list.toArray();
        //调用Arrays类的static  Stream stream(T[] array)：返回一个流
        Stream