20、Lambda表达式和Stream

一、Lambda表达式

1、Lambda简介

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。

JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

2、对接口的要求

虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个 抽象方法 ，不是规定接口中只能有一个方法 。

jdk 8 中有另一个新特性：default，被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。

@FunctionalInterface

修饰函数式接口的，要求接口中的抽象方法只有一个。这个注解往往会和 lambda 表达式一起出现。

3、Lambda基础语法

我们这里给出六个接口，后文的全部操作都利用这六个接口来进行阐述。

java 复制代码

public class LambdaInterface {
}
/**
 * 无参无返回值
 */
@FunctionalInterface
interface NoReturnNoParam {
    void method();
}

/**
 * 一个参数无返回
 */
@FunctionalInterface
interface NoReturnOneParam {
    void method(int a);
}

/**
 * 多参数无返回
 */
@FunctionalInterface
interface NoReturnMultiParam {
    void method(int a, int b);
}

/*** 无参有返回*/
@FunctionalInterface
interface ReturnNoParam {
    int method();
}

/**
 * 一个参数有返回值
 */
@FunctionalInterface
interface ReturnOneParam {
    int method(int a);
}

/**
 * 多个参数有返回值
 */
@FunctionalInterface
interface ReturnMultiParam {
    int method(int a, int b);
}

语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符，读作(goes to)。

4、Lambda基础语法测试

java 复制代码

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

        //无参无返回
        NoReturnNoParam noReturnNoParam = () -> {
            System.out.println("NoReturnNoParam");
        };
        noReturnNoParam.method();

        //一个参数无返回
        NoReturnOneParam noReturnOneParam = (int a) -> {
            System.out.println("NoReturnOneParam param:" + a);
        };
        noReturnOneParam.method(6);

        //多个参数无返回
        NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
            System.out.println("NoReturnMultiParam param:" + "{" + a +"," + + b +"}");
        };
        noReturnMultiParam.method(6, 8);

        //无参有返回值
        ReturnNoParam returnNoParam = () -> {
            System.out.print("ReturnNoParam");
            return 1;
        };

        int res = returnNoParam.method();
        System.out.println("return:" + res);

        //一个参数有返回值
        ReturnOneParam returnOneParam = (int a) -> {
            System.out.println("ReturnOneParam param:" + a);
            return 1;
        };

        int res2 = returnOneParam.method(6);
        System.out.println("return:" + res2);

        //多个参数有返回值
        ReturnMultiParam returnMultiParam = (int a, int b) -> {
            System.out.println("ReturnMultiParam param:" + "{" + a + "," + b +"}");
            return 1;
        };
        int res3 = returnMultiParam.method(6, 8);
        System.out.println("return:" + res3);
    }
}

5、Lambda语法简化测试

我们可以通过观察以下代码来完成代码的进一步简化，写出更加优雅的代码。

java 复制代码

public class Test2 {
    public static void main(String[] args) {
        //1.简化参数类型，可以不写参数类型，但是必须所有参数都不写
        NoReturnMultiParam lamdba1 = (a, b) -> {
            System.out.println("简化参数类型");
        };
        lamdba1.method(1, 2);

        //2.简化参数小括号，如果只有一个参数则可以省略参数小括号
        NoReturnOneParam lambda2 = a -> {
            System.out.println("简化参数小括号");
        };
        lambda2.method(1);

        //3.简化方法体大括号，如果方法条只有一条语句，则可以省略方法体大括号
        NoReturnNoParam lambda3 = () -> System.out.println("简化方法体大括号");
        lambda3.method();

        //4.如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号
        ReturnOneParam lambda4 = a -> a + 3;
        System.out.println(lambda4.method(5));

        ReturnMultiParam lambda5 = (a, b) -> a + b;
        System.out.println(lambda5.method(1, 1));
    }
}

6、Lambda表达式常用示例

Lambda表达式引用方法

有时候我们不是必须要自己重写某个匿名内部类的方法，我们可以可以利用 lambda表达式的接口快速指向一个已经被实现的方法。

语法

方法归属者::方法名静态方法的归属者为类名，普通方法归属者为对象

java 复制代码

public class Exe1 {
    public static void main(String[] args) {
        ReturnOneParam lambda1 = a -> doubleNum(a);
        System.out.println(lambda1.method(3));

        //lambda2 引用了已经实现的静态 doubleNum 方法
        ReturnOneParam lambda2 = Exe1::doubleNum;
        System.out.println(lambda2.method(3));

        Exe1 exe = new Exe1();

        //lambda4 引用了已经实现的非静态 addTwo 方法
        ReturnOneParam lambda4 = exe::addTwo;
        System.out.println(lambda4.method(2));
    }
    /**
     * 要求
     * 1.参数数量和类型要与接口中定义的一致
     * 2.返回值类型要与接口中定义的一致
     */
    public static int doubleNum(int a) {
        return a * 2;
    }
    public int addTwo(int a) {
        return a + 2;
    }
}

Lambda表达式创建线程

我们以往都是通过创建 Thread 对象，然后通过匿名内部类重写 run() 方法，一提到匿名内部类我们就应该想到可以使用 lambda 表达式来简化线程的创建过程。

java 复制代码

Thread t = new Thread(() -> {
    for (int i = 0; i < 10; i++) {
        System.out.println(2 + ":" + i);
    }
});
t.start();

遍历集合

我们可以调用集合的 public void forEach(Consumer<? super E> action) 方法，通过 lambda 表达式的方式遍历集合中的元素。以下是 Consumer 接口的方法以及遍历集合的操作。Consumer 接口是 jdk 为我们提供的一个函数式接口。

java 复制代码

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
    //....
}

ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 1,2,3,4,5);
//lambda表达式 方法引用
list.forEach(System.out::println);
list.forEach(element -> {
    if (element % 2 == 0) {
        System.out.println(element);
    }
});

删除集合中的某个元素

我们通过public boolean removeIf(Predicate<? super E> filter)方法来删除集合中的某个元素，Predicate 也是 jdk 为我们提供的一个函数式接口，可以简化程序的编写。

java 复制代码

ArrayList<Item> items = new ArrayList<>();
items.add(new Item(11, "小牙刷", 12.05 ));
items.add(new Item(5, "日本马桶盖", 999.05 ));
items.add(new Item(7, "格力空调", 888.88 ));
items.add(new Item(17, "肥皂", 2.00 ));
items.add(new Item(9, "冰箱", 4200.00 ));

items.removeIf(ele -> ele.getId() == 7);

//通过 foreach 遍历，查看是否已经删除
items.forEach(System.out::println);

集合内元素的排序

在以前我们若要为集合内的元素排序，就必须调用 sort 方法，传入比较器匿名内部类重写 compare 方法，我们现在可以使用 lambda 表达式来简化代码。

java 复制代码

ArrayList<Item> list = new ArrayList<>();
list.add(new Item(13, "背心", 7.80));
list.add(new Item(11, "半袖", 37.80));
list.add(new Item(14, "风衣", 139.80));
list.add(new Item(12, "秋裤", 55.33));

/*
list.sort(new Comparator<Item>() {
    @Override
    public int compare(Item o1, Item o2) {
        return o1.getId()  - o2.getId();
    }
});
*/

list.sort((o1, o2) -> o1.getId() - o2.getId());
System.out.println(list);

二、Stream流式处理集合

1、知识点概述

2、Stream概述

Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。

Stream可以由数组或集合创建，对流的操作分为两种：

中间操作，每次返回一个新的流，可以有多个
中断操作，每个流只能进行一次中断操作，中断操作结束后流无法再次使用。中断操作会产生一个新的集合或值。
stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
stream不会改变数据源，通常情况下会产生一个新的集合或一个值
stream具有延迟执行特性，只有调用中断操作时，中间操作才会执行

3、Stream的创建

Stream可以通过集合数组创建。

通过 java.util.Collection.stream() 方法用集合创建流
使用java.util.Arrays.stream(T[] array)方法用数组创建流
使用Stream的静态方法：of()、iterate()

java 复制代码

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * Stream 流的创建有3种方式
 *  *  1. Collection.stream（）方法用集合创建
 *  *  2. Arrays.stream(T[] array) 方法用数组创建
 *  *  3. 使用Stream的静态方法：of()、iterate()
 */
public class StreamCreateType {
    public static void main(String[] args) {
        //1. Collection.stream（）方法用集合创建
        List<String> list = Arrays.asList("1","2","3");
        // 创建一个顺序流
        Stream<String> stream = list.stream();
        // 创建一个并行流
        Stream<String> stringStream = list.parallelStream();
        List<String> collect = stringStream.collect(Collectors.toList());

        //2. Arrays.stream(T[] array) 方法用数组创建
        int[] array={1,2,3,4,5};
        IntStream stream1 = Arrays.stream(array);
        System.out.println(stream1.max().getAsInt());

        //3.  使用Stream的静态方法：of()、iterate()、generate()
        Stream<Integer> intStream = Stream.of(1, 2, 3, 4, 5, 6);
        Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
        // 0 3 6 9
        stream2.forEach(System.out::println);
    }
}

注意：

stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。

4、Stream的使用

新建实体类Person,后续用于Stream操作

Emp

java 复制代码

package com.yjxxt;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 员工类，雇员
 */
public class Emp {

    private Integer empno;      //员工编号
    private String ename;       //员工的名字
    private String job;         //员工工种
    private Integer mgr;        //员工上司的编号
    private Date hiredate;      //入职日期
    private Double sal;         //员工工资
    private Double comm;        //员工奖金
    private Integer deptno;     //员工的部门编号

    @Override
    public String toString() {
        return "Emp{" +
                "empno=" + empno +
                ", ename='" + ename + '\'' +
                ", job='" + job + '\'' +
                ", mgr=" + mgr +
                ", hiredate=" + hiredate +
                ", sal=" + sal +
                ", comm=" + comm +
                ", deptno=" + deptno +
                '}';
    }

    public Emp() {
    }

    public Emp(Integer empno, String ename, String job, Integer mgr, Date hiredate, Double sal, Double comm, Integer deptno) {
        this.empno = empno;
        this.ename = ename;
        this.job = job;
        this.mgr = mgr;
        this.hiredate = hiredate;
        this.sal = sal;
        this.comm = comm;
        this.deptno = deptno;
    }

    public static List<Emp> geneEmpList() {
        List<Emp> empList = new ArrayList<>();
        empList.add(new Emp(7369, "SMITH", "CLERK", 7902, new Date(), 800.00, null, 20));
        empList.add(new Emp(7499, "ALLEN", "SALESMAN", 7698, new Date(), 1600.00, 300.00, 30));
        empList.add(new Emp(7521, "WARD", "SALESMAN", 7698, new Date(), 1250.00, 500.00, 30));
        empList.add(new Emp(7566, "JONES", "MANAGER", 7839, new Date(), 2975.00, null, 20));
        empList.add(new Emp(7654, "MARTIN", "SALESMAN", 7698, new Date(), 1250.00, 1400.00, 30));
        empList.add(new Emp(7698, "BLAKE", "MANAGER", 7839, new Date(), 2850.00, null, 30));
        empList.add(new Emp(7782, "CLARK", "MANAGER", 7839, new Date(), 2450.00, null, 10));
        empList.add(new Emp(7788, "SCOTT", "ANALYST", 7566, new Date(), 3000.00, null, 20));
        empList.add(new Emp(7839, "KING", "PRESIDENT", null, new Date(), 5000.00, null, 10));
        empList.add(new Emp(7844, "TURNER", "SALESMAN", 7698, new Date(), 1500.00, 0.00, 30));
        empList.add(new Emp(7876, "ADAMS", "CLERK", 7788, new Date(), 1100.00, null, 20));
        empList.add(new Emp(7900, "JAMES", "CLERK", 7698, new Date(), 950.00, null, 30));
        empList.add(new Emp(7902, "FORD", "ANALYST", 7566, new Date(), 3000.00, null, 20));
        empList.add(new Emp(7934, "MILLER", "CLERK", 7782, new Date(), 1300.00, null, 10));
        return empList;
    }


public Integer getEmpno() {
        return empno;
    }

    public void setEmpno(Integer empno) {
        this.empno = empno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public Integer getMgr() {
        return mgr;
    }

    public void setMgr(Integer mgr) {
        this.mgr = mgr;
    }

    public Date getHiredate() {
        return hiredate;
    }

    public void setHiredate(Date hiredate) {
        this.hiredate = hiredate;
    }

    public Double getSal() {
        return sal;
    }

    public void setSal(Double sal) {
        this.sal = sal;
    }

    public Double getComm() {
        return comm;
    }

    public void setComm(Double comm) {
        this.comm = comm;
    }

    public Integer getDeptno() {
        return deptno;
    }

    public void setDeptno(Integer deptno) {
        this.deptno = deptno;
    }
}

遍历/匹配（foreach/find/match）

Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历非常简单。

java 复制代码

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo06Foreach {

    public static void main(String[] args) {

        //创建集合
        List<Emp> emps = Emp.geneEmpList();
        //获取流对象
        //1.forEach(Consumer c) 中断操作
        emps.stream().forEach(emp -> System.out.println(emp));

        //2.findFirst(); 获取流中的第一个元素    中断操作
        //  findAny(); 获取返回任意元素，默认返回第一个  中断操作
        Optional<Emp> opt = emps.stream().findFirst();
        //Optional是jdk1.8推出的一个功能类，该类包装了流返回个单个结果
        if (opt.isPresent()){
            Emp emp = opt.get();
            System.out.println("findFirst:" + emp);
        }

        Optional<Emp> any = emps.stream().findAny();
        if (any.isPresent()){
            Emp emp = any.get();
            System.out.println("findAny:" + emp);
        }


        //3.match 匹配
        // allMatch 流中所有的元素都满足条件返回true    中断操作
        // anyMatch 流中任何元素之一满足条件返回true    中断操作
        // noneMatch 流中任何元素都不满足条件返回true   中断操作
        boolean b = emps.stream().allMatch(emp -> emp.getSal() > 1000);//判断流中的任何一个人的工资都要大于1000
        System.out.println("所有人的工资都大于1000吗？" + b);

        boolean b1 = emps.stream().anyMatch(emp -> emp.getSal() >= 1000);//判断流中的任何一个人工资大于1000，就返回true
        System.out.println("任意一人的工资大于1000吗？" + b1);

        boolean b2 = emps.stream().noneMatch(emp -> emp.getSal() < 1000);//判断流中没有人的工资小于1000，就返回true
        System.out.println("没有任何人的工资小于1000吗？" + b2);


//        List<Emp> empList = new ArrayList<>();
//        Emp emp = empList.stream().findFirst();
//        emp.toString(); //NullPointerException
    }
}

筛选（filter）

筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。

java 复制代码

import java.util.List;
import java.util.function.Predicate;

public class Demo07Filter {

    public static void main(String[] args) {

        List<Emp> empList = Emp.geneEmpList();

        // filter(Predicate) 过滤 中间操作
        //查找20部门的员工
        empList.stream()
                .filter(emp -> emp.getDeptno() == 20)
                .forEach(emp -> System.out.println(emp));

        System.out.println("================华丽分割线================");
        //获取工资大于2000的员工
        empList.stream()
                .filter(emp -> emp.getSal() > 2000)
                .forEach(emp -> System.out.println(emp));

        System.out.println("================华丽分割线================");

        //查找20部门且工资大于2000的员工
        empList.stream()
                .filter(emp -> emp.getSal() > 2000)
                .filter(emp -> emp.getDeptno() == 20)
                .forEach(emp -> System.out.println(emp));
    }
}