Java——lambda表达式和StreamAPI

一、lambda

1. lambda表达式

1.1 Lambda表达式的使用举例:

(o1,02)->Integer.compare(o1,o2);

1.2 Lambda表达式的格式举例:

Lambda形参列表->lambda

1.3 Lambda表达式的格式

lambda操作符或箭头操作符

的左边:lambda形参列表，对应着要重写的接口中的抽象方法的形参列表。
的右边:lambda体，对应着接口的实现类要重写的方法的方法体。

1.4 Lambda表达式的本质

一方面，lambda表达式作为接口的实现类的对象。--->"万事万物皆对象
另一方面，lambda表达式是一个匿名函数。

lambda使用格式实例

    //lambda表达式的使用练习1
    //lambda需要两个或以上的参数时，多条执行语句，并有返回值时
    @Test
    public void test7(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {

            }
        };
        int compare1 = com1.compare(21,35);
        System.out.println(compare1);

        System.out.println("**********下面为使用lambda表达式*********");

        Comparator<Integer> com2 = (o1,o2) ->{
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        int compare2 = com2.compare(12,32);
        System.out.println(compare1);
    }



    //lambda表达式的使用练习2
    //两个参数，一个返回值
    @Test
    public void test7(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare1 = com1.compare(21,35);
        System.out.println(compare1);

        System.out.println("**********下面为使用lambda表达式*********");
        Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);
        int compare2 = com2.compare(12,32);
        System.out.println(compare1);
    }

    //lambda表达式的使用练习3
    //无参，无返回值
    @Test
    public void test10(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("去北京喝豆汁");
            }
        };
        r1.run();
        System.out.println("**********下面为使用lambda表达式*********");

        Runnable r2 = () -> System.out.println("去四川吃火锅");
        r2.run();
    }

    //lambda表达式的使用练习4
    //只有一个参数
    @Test
    public void test11(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("好像在哪里见过？");

        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("我想在梦里遇见你！");

    }

1.5.函数式接口:
问题一：什么是函数式接口?为什么需要函数式接口?

如果接口中只声明有一个抽象方法，则此接口就称为函数式接口。
因为只有给函数式接口提供实现类的对象时，我们才可以使用lambda表达式:

问题二：api中函数式接口所在的包

jdk8中声明的函数式接口都在java.util.function包下

问题三：4个基本的函数式接口

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

函数式接口的使用实例：

/*ConsumerConsumer<T> void accept(T t);*/
    //语法格式：lambda表达式使用时，只有一个参数，可以省略掉()
    @Test
    public void test11(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("好像在哪里见过？");

        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("我想在梦里遇见你！");

    }

    /*Supplier<T> T get();*/
    @Test
    public void test12(){
        //构造器引用
        Supplier<Person> sup1 = Person :: new;
        System.out.println(sup1.get());
    }


    /*Function<T, R> R apply(T t)*/
    @Test
    public void test13(){
        Function<Integer,Person> fun1 = Person::new;
        System.out.println(fun1.apply(14));
    }

    /*BiFunction<T, U, R>  R apply(T t, U u)*/
    @Test
    public void test14(){
        BiFunction<String, Integer, Person> bif = Person::new;
        System.out.println(bif.apply("Tom", 18));
    }

1.6 语法规则总结;

->的左边:lambda形参列表，参数的类型都可以省略。如果形参只有一个，则一对()也可以省略
->的右边:lambda体，对应着重写的方法的方法体。如果方法体中只有一行执行语句，则一对{可以省略，若有return关键字，则必须一并省略。

2. 方法引用

2.1 方法的格式：

Integer::compare

2.2 方法引用的埋解

方法引用，可以看做是基于lambda表达式的进一步刻画
当需要提供一个函数式接口的实例时，我们可以使用lambda表达式提供此实例。

>当满足一定的条件的情况下，我们还可以使用方法引用或构造器引用替换lambda表达式

2.3 方法引用的本质:

方法引用作为了函数式接口的实例。--->“万事万物皆对象"

2.4 格式:

类(或对象)::方法名

2.5.具体使用情况

情况1: 对象::实例方法

要求:函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的形参列表和返回值类都相同
此时，可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。

注意:此方法b是非静态的方法，需要对象调用

代码实例

/*情况一：对象::实例方法
    * Consumer中的void accept(T t)
    * PrintStream中的void println(T t)
    * */
    @Test
    public void test1(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };

        con.accept("喜羊羊与灰太狼");

        //lambda表达式
        Consumer<String> con1 = s->System.out.println(s);
        con1.accept("美羊羊与沸羊羊");

        //方法引用
        Consumer<String> con2 = System.out::println;
        con2.accept("懒洋洋的睡一觉");
    }

    /*Supplier中的get()方法
    * Employee中的String getName()
    * */
    @Test
    public void test2(){
        Employee emp = new Employee(1002,"马云",2, 9876.12);
        Supplier<String> sup1 = new Supplier<String>() {
            @Override
            public String get() {
                return emp.getName();
            }
        };

        System.out.println(sup1.get());

        //lambda方法
        Supplier<String> sup2 = ()-> emp.getName();
        System.out.println(sup2.get());

        //方法引用
        Supplier<String> sup3 = emp::getName;
        System.out.println(sup3.get());

    }

情况2: 类::静态方法

要求:

函数式接口中的抽象方法a与其内部实现时调用的类的某个静态方法b的形参列表和返回值类型都相同(或一致)，此时，可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用。

注意:此方法b是静态的方法，需要类调用。

代码实例

//情况二：类::静态方法
    /*
    * Comparator中的int compare(T t,T t)
    * Integer中的int compare(T t,T t)
    * */
    @Test
    public void test3(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        System.out.println(com1.compare(12, 21));

        //lambda表达式
        Comparator<Integer> com2 = (o1 ,o2)->Integer.compare(o1,o2);
        System.out.println(com2.compare(21, 22));

        //方法引用
        Comparator<Integer> com3 = Integer::compare;
        System.out.println(com3.compare(44, 43));
    }

    /*
     * Function中的apply(T t)
     * Math中的long round(Double d)
     * */
    @Test
    public void test4(){
        Function<Double,Long> fun1 = new Function<Double, Long>() {
            @Override
            public Long apply(Double aDouble) {
                return Math.round(aDouble);//四舍五入
            }
        };
        System.out.println(fun1.apply(1.4));

        Function<Double,Long> fun2 = aDouble -> Math.round(aDouble);
        System.out.println(fun2.apply(1.6));

        Function<Double,Long> fun3 = Math::round;
        System.out.println(fun3.apply(2.1));
    }

情况3: 类::实例方法

要求:

函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的返回值类型相同。同时，抽象方法a中有n个参数，方法b中有n-1个参数，且抽象方法a的第1个参数作为方法b的调用者，且抽象方法a的后n-1个参数与方法b的n-1个参数的类型相同(或一致)。则可以考虑使用方法b实现对方法a的替换、覆盖。此替换或覆盖即为方法引用

注意:此方法b是非静态的方法，需要对象调用。但是形式上，写出对象a所属的类

代码实例

    //情况三：类::实例方法(难)
    /*
    * Comparator的int compare(T t,T t)
    * String中的int t1.compare(t2)
    *  */
    @Test
    public void test5(){
        Comparator<String> com1 = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        };



        //方法引用
        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("abb","abb"));
    }

    /*
    * BiPredicate中的boolean test(T t1,T t2)
    * String中的boolean t1.equals(t2)
    * */
    @Test
    public void test6(){
        BiPredicate<String,String> bip = new BiPredicate<String, String>() {
            @Override
            public boolean test(String s1, String s2) {
                return s1.equals(s2);
            }
        };
        System.out.println(bip.test("10001", "10001"));

        //lambda表达式
        BiPredicate<String,String> bip1 = (s1,s2)->s1.equals(s2);
        System.out.println(bip.test("103", "1031"));

        //方法引用
        BiPredicate<String,String> bip2 = String::equals;
        System.out.println(bip.test("101", "10"));
    }

    /*
    * Function中的R apply(T t)
    * Employee中的string getName();
    * */
    @Test
    public void test7(){
        Employee emp = new Employee(1003,"刘强东",33,3000.82);

        Function<Employee,String> fun1 = new Function<Employee, String>() {
            @Override
            public String apply(Employee employee) {
                return emp.getName();
            }
        };
        System.out.println(fun1.apply(emp));

        //方法引用
        Function<Employee,String> fun2 = Employee::getName;
        System.out.println(fun2.apply(emp));
    }
}

3. 构造器引用

3.1 格式

类名:: new

3.2 说明

调用了类名对应的类中的某一个确定的构造器
具体调用的是类中的哪一个构造器呢?取决于函数式接口的抽象方法的形参列表!

3.3 代码示例

    /*Supplier<T> T get();*/
    @Test
    public void test12(){
        //构造器引用
        Supplier<Person> sup1 = Person :: new;
        System.out.println(sup1.get());
    }


    /*Function<T, R> R apply(T t)*/
    @Test
    public void test13(){
        Function<Integer,Person> fun1 = Person::new;
        System.out.println(fun1.apply(14));
    }

    /*BiFunction<T, U, R>  R apply(T t, U u)*/
    @Test
    public void test14(){
        BiFunction<String, Integer, Person> bif = Person::new;
        System.out.println(bif.apply("Tom", 18));
        //调用的是参数Integer和String类型，所以出来的是名字和年龄
    }

4. 数组引用

格式: 数组名[]::new

代码示例

//  数组引用
    @Test
    public void test15(){
        Function<Integer, Person[]> fun2 = new Function<Integer, Person[]>() {
            @Override
            public Person[] apply(Integer length) {
                return new Person[length];
            }
        };
        System.out.println(fun2.apply(13).length);

        Function<Integer,Person[]> fun1 = Person[] :: new;
        System.out.println(fun1.apply(14).length);//数组的长度等于14
    }

二、StreamAPI

前言：

问题：什么是Stream？
Stream 是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。
Stream 和 Collection 集合的区别: Collection 是一种静态的内存数据结构，讲的是数据，而 stream 是有关计算，讲的是计算。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过 CPU 实现计算。

1.Stream API vs 集合框架

Stream API 关注的是多个数据的计算(排序、查找、过滤、映射、遍历等)，面向CPU的。
集合关注的数据的存储，面向内存的。

即：Stream API 之于集合，类似于SOL之于数据表的查询。

2.使用说明

Stream 自己不会存储元素。
Stream不会改变源对象。相反，他们会返回一个持有结果的新stream。
Stream, 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。即一旦执行终止操作，就执行中间操作链，并产生结果。
Stream一旦执行了终止操作，就不能再调用其它中间操作或终止操作了。

3.Stream 执行流程

Stream的操作三个步骤
1.创建 stream

一个数据源(如:集合、数组)，获取一个流

2.中间操作

每次处理都会返回一个持有结果的新stream，即中间操作的方法返回值仍然是stream类型的对象。因此中间操作可以是个操作链，可对数据源的数据进行n次处理，但是在终结操作前，并不会真正执行。

3.终止操作

终止操作的方法返回值类型就不再是stream了，因此一旦执行终止操作，就结束整个stream操作了。一旦执行终止操作，就执行中间操作链，最终产生结果并结束stream。

图示：

3.1 Stream的实例化

1.三种实例化的方式

方式一：通过集合创建Stream实例
方式二：通过数组创建Stream实例
方式三：通过Stream.of()方式创建Stream实例

2.实例化代码实现

package data;

import org.junit.Test;

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

public class StreamAPiTest {
    //创建Stream方式一：通过集合
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
        //返回一个顺序流
        Stream<Employee> stream = list.stream();

        //返回一个并行流
        Stream<Employee> stream1 = list.parallelStream();

        System.out.println(stream);
        System.out.println(stream1);
    }

    //创建Stream方式二：使用数组
    @Test
    public void test2(){
        //调用Arrays类的static <T>  Stream <T> Stream(T[] array): 返回一个流
        Integer[] arr = new Integer[] {1,2,3,4,5};
        Stream<Integer> stream = Arrays.stream(arr);

        int[] arr1 = new int[]{1,2,3,4,5};
        IntStream stream1 = Arrays.stream(arr1);
    }


    //创建Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<String> stream = Stream.of("AA","BB","CC","DD","EE");
    }
}

3.2 中间操作

1.筛选与切片

方法	描述
`filter(Predicate p)`	接收一个 Lambda ，过滤掉不符合条件的元素。
`distinct()`	筛选，通过流所生成元素的 `hashCode()` 和 `equals()` 方法去除重复元素。
`limit(long maxSize)`	截断流，使其元素数量不超过指定数量。
`skip(long n)`	跳过前 `n` 个元素，返回一个新的流。若流中元素不足 `n` 个，则返回一个空流，与 `limit(n)` 互补。

2.映射

方法	描述
`map(Function f)`	接收一个函数作为参数，该函数应用于每个元素，并映射成一个新的元素。
`mapToDouble(ToDoubleFunction f)`	接收一个函数作为参数，该函数应用于每个元素，产生一个新的 `DoubleStream`。
`mapToInt(ToIntFunction f)`	接收一个函数作为参数，该函数应用于每个元素，产生一个新的 `IntStream`。
`mapToLong(ToLongFunction f)`	接收一个函数作为参数，该函数应用于每个元素，产生一个新的 `LongStream`。
`flatMap(Function f)`	接收一个函数作为参数，将流中的每个值换成另一个流，然后将所有流连接成一个流。

3.排序

方法	描述
`sorted()`	产生一个新流，其中按自然顺序排序。
`sorted(Comparator com)`	产生一个新流，其中按提供的比较器顺序排序。

4.中间操作代码实现

//中间操作
    //筛选与切片
    @Test
    public void test4(){
        //filter(Predicate p)，接收lambda方法---移除某些元素
        //集合实例化
        List<Employee> list = EmployeeData.getEmployees();

        //通过集合创建Stream的实例
        Stream<Employee> stream = list.stream();

        //查询员工表中薪资大于7000的员工的信息
        stream.filter(emp -> emp.getSalary() > 7000).forEach(System.out::println);

        System.out.println("************************");
        //由于在上面Stream已经实行了终止操作，所以不可以在调用其他方法的终止操作
        //limit--截断流，使其元素不超过指定数量
        list.stream().filter(emp->emp.getSalary() > 7000).limit(2).forEach(System.out::println);

        //skip--跳过流，跳过前n个元素
        list.stream().skip(4).forEach(System.out::println);

    }
    
    
    //映射
    @Test
    public void test5(){
        //map(Function f)接收一个函数作为参数，该函数应用于每个元素，并映射成一个新的元素。
        //转换为大写   toUpperCase() 将字符串转换为大写
        List<String> list = Arrays.asList("aa","bb","cc","dd");
        list.stream().map(String::toUpperCase).forEach(System.out::println);

        //获取姓名长度大于3的员工的姓名
        List<Employee> employees = EmployeeData.getEmployees();
        //先过滤后映射
        employees.stream().filter(emp->emp.getName().length() > 3).map(Employee::getName).forEach(System.out::println);
        //先映射后过滤
        employees.stream().map(Employee::getName).filter(name->name.length()>3).forEach(System.out::println);
    }
    
    
    //排序
    @Test
    public void test6(){
        //sorted()--自然排序
        Integer[] arr = new Integer[]{12,34,65,23,1,23,4,45};
        String[] arr1 = new String[]{"SS","EE","CC","BB","AA"};

        //使用数组创建Stream实例
        Arrays.stream(arr).sorted().forEach(System.out::println);

        //原本的数组并没有升序，而调整
        //Stream不会改变原对象
        System.out.println(Arrays.toString(arr));

        //sorted(comparator c)--定制排序
        Arrays.stream(arr1).sorted(String::compareTo).forEach(System.out::println);
    }

3.3 终止操作

1.匹配与查找

方法	描述
`allMatch(Predicate p)`	检查是否匹配所有元素
`anyMatch(Predicate p)`	检查是否至少匹配一个元素
`noneMatch(Predicate p)`	检查是否没有匹配任何元素
`findFirst()`	返回第一个元素
`findAny()`	返回当前流中的任意元素
`count()`	返回流中元素的总数
`max(Comparator c)`	返回流中元素的最大值
`min(Comparator c)`	返回流中元素的最小值
`forEach(Consumer c)`	对流中的每个元素执行给定的操作（内部迭代）

2.归约

方法	描述
`reduce(T identity, BinaryOperator b)`	可将流中元素反复结合起来，得到一个值。返回T
`reduce(BinaryOperator b)`	可将流中元素反复结合起来，得到一个值。返回 `Optional<T>`

3.收集

方法	描述
`collect(Collector c)`	将流转换为其他形式。接收一个 `Collector` 接口的实现，用于给Stream中的元素汇总的方法

4.终止操作代码实现

//终止操作
    //匹配与查找
    @Test
    public void test7(){
        //allMatch检查是否匹配所有元素
        //是否所有员工都大于20岁
        List<Employee> list = EmployeeData.getEmployees();
        System.out.println(list.stream().allMatch(emp -> emp.getAge() > 20));

        //anyMatch检查是否至少一个元素满足要求
        System.out.println(list.stream().anyMatch(emp -> emp.getSalary() > 9600));

        //findFirst返回第一个元素
        System.out.println(list.stream().findFirst().get());

        //findAny返回任意一个元素
        System.out.println(list.stream().findAny().get());

        //count 返回流中元素的总数
        System.out.println(list.stream().filter(emp -> emp.getSalary() > 7000).count());

        //max(Comparator c) 返回流中最大值
        System.out.println(list.stream().max((a1, a2) -> Integer.compare(a1.getAge() , a2.getAge())));

        //min(Comparator c) 返回流中最大值
        System.out.println(list.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));

        //forEach(Consumer c)，遍历
        list.stream().forEach(System.out::println);
    }


    //归约
    @Test
    public void test8(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        //reduce(T identity, BinaryOperator b)
        //可将流中元素反复结合起来，得到一个值。返回T
        //操作;计算1-10的和
        System.out.println(list.stream().reduce(0, (s1, s2) -> s1 + s2));
        //前面的0或者10，相当于起始值
        System.out.println(list.stream().reduce(5, (s1, s2) -> s1 + s2));

        System.out.println(list.stream().reduce(15, Integer::sum));



        //reduce(BinaryOperator b)
        //可将流中元素反复结合起来，得到一个值。返回Optional<T>
        //操作：计算公司所有员工工资的总额

        List<Employee> list1 = EmployeeData.getEmployees();
        //先映射后计算
        list1.stream().map(emp->emp.getSalary()).reduce((s1,s2)->Double.sum(s1,s2));
        list1.stream().map(emp->emp.getSalary()).reduce(Double::sum);

    }

    //收集
    @Test
    public void test9(){
        /*collect(Collector c)
        将流转换为其他形式。接收一个Collector接口的实现
        用于给Stream中的元素汇总的方法*/
        //题目1：查找工资大于6000的员工，结果返回set或list
        List<Employee> list = EmployeeData.getEmployees();
        List<Employee> list1 = list.stream().filter(emp -> emp.getSalary() > 6000).collect(Collectors.toList());
        Set<Employee> list2 = list.stream().filter(emp -> emp.getSalary() > 6000).collect(Collectors.toSet());

        list.forEach(System.out::println);
        System.out.println();

        list1.forEach(System.out::println);
        System.out.println();

        list2.forEach(System.out::println);
        System.out.println();

        //题目2：按照员工的年龄排序，返回一个list
        //升
        List<Employee> list3 = list.stream().sorted((e1,e2)->e1.getAge()-e2.getAge()).collect(Collectors.toList());
        list3.forEach(System.out::println);

        System.out.println();

        //降
        List<Employee> list4 = list.stream().sorted((e1,e2)-> -(e1.getAge()-e2.getAge())).collect(Collectors.toList());
        list4.forEach(System.out::println);

    }