培训 | Lambda表达式详解

什么是Lambda

Lambda (大写 Λ ，小写 λ) 读音：lan b (m) da (兰亩达) [‘læ;mdə]
Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。
JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

对接口的要求

虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda只能接受函数式接口，所谓的函数式接口指的是只能有一个抽象方法的接口，或者说只能有一个需要被实现的方法，不是规定接口中只能有一个方法。
jdk 8 中有另一个新特性：default， 被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。

@Functionallnterface
修饰函数式接口的，要求接口中的抽象方法只有一个。这个注解往往会和 lambda 表达式一起出现。
该注解是给编译器做检查使用的，如果使用了该注解，编译器就会检查该接口中的抽象方法是不是只有一个，如果有多个就会报错：在接口Xxx中找到多个非覆盖抽象方法

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

Lambda语法

Lambda表达式通过操作符->分为两个部分：

• 左侧：指定了Lambda表达式所需要的所有参数。
• 右侧：指定了Lambda体，即Lambda表达式所要执行的功能。

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

一行执行语句的写法：
(parameters) -> expression
如果有多行执行语句，可以加上 {}
(parameters) -> { statements; }
如：

public int add(int x, int y) {
    return x + y;
}

转换成Lambda表达式有以下几种写法：

// 指定参数类型及return
(int x, int y) -> { return x + y; }
// 指定参数类型，不指定return
(int x, int y) -> x + y;
// 不指定参数类型和return，编译器会自动推断
(x, y) -> x + y;

Lambda表达式的基本语法结构如下，当然，这里只是简单的Lambda 表达式的应用。

Lambda对语法的简化（说明示例）

1. 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值

   (int a, int b) -> {System.out.println(a + “,” + b)} 等价于 (a, b) -> {System.out.println(a + “,” + b)}

2. 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号

   (a) -> {System.out.println(a)} 等价于 a -> {System.out.println(a)}

3. 可选的大括号：如果主体包含了一个语句，就不需要使用大括号

   a -> {System.out.println(a)} 等价于 a -> System.out.println(a)

1. 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值

   a -> return a 等价于 a -> a

Lambda对语法的简化（代码示例）

// 无参数、无返回值
@FunctionalInterface
public interface NoReturnNoParam {
    void method();
}
// 1参数、无返回值
@FunctionalInterface
public interface NoReturnOneParam {
    void method(String a);
}
// 多参数、无返回值
@FunctionalInterface
public interface NoReturnMultiParam {
    void method(String a, String b);
}
// 无参数、有返回值
@FunctionalInterface
public interface ReturnNoParam {
    String method();
}
// 1参数、有返回值
@FunctionalInterface
public interface ReturnOneParam {
    String method(String a);
}
// 多无参数、有返回值
@FunctionalInterface
public interface ReturnMultiParam {
    String method(String a, String b);
}

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);
    }
}

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

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));
    }
}

手写一个示例

public interface IHello {
    String sayHello(String name, String msg);
}

public class IHelloImpl {
    public static void main(String[] args) {
        // 将一个Lambda表达式赋值给一个接口，说明Lambda表达式就是一种接口数据类型，只不过该接口只能有一个抽象方法
        // 参数列表可以省略参数类型，可以写成(name, msg)，在JDK1.8中有个叫做类型推断的东西，可以自动推断出参数的类型，
        // 因为IHello中只有一个抽象方法,知道方法了就知道参数列表了，从而就能推出参数类型来
        IHello iHello = (String name, String msg) -> {
            String hello = name + ": " + msg;
            return hello;
        };
        // 调用接口的方法
        String content = iHello.sayHello("mengday", "happy new year everyone!");
        System.out.println(content);
    }
}

函数式接口

函数式接口介绍

函数式接口的定义：只允许有一个抽象方法的接口，那么它就是一个函数式接口。针对函数式接口，官方给我们提供了一个注解@FunctionalInterface，该注解会检查它是否是一个函数式接口，所以如果我们需要自定义一个函数式接口的话，可以在接口类的上方声明@FunctionalInterface。
需要注意的是，数式接口虽然规定只能有一个抽象方法，但是同时可以有多个非抽象方法（如静态方法，默认方法，私有方法）。下面是一个自定义的函数式接口：

@FunctionalInterface
public interface FunctionalInterface {
    /**
     * 抽象方法(只能有一个)
     */
    void method();
    //void method1();再定义一个会提示：找到多个抽象方法
    /**
     * 默认方法,必须用default修饰
     */
    default void defaultMethod() {
        System.out.println("默认方法...");
    }
    /**
     * 静态方法方法
     */
    static void staticMethod() {
        System.out.println("静态方法...");
    }
}

四大类型接口

Java8中增加了一个包：java.util.function。它们里面包含了常用的函数式接口，该包下定义的函数式接口非常多，主要有四大类：

可以看出四种函数式接口抽象方法的特点如下：

• 消费型接口：有参数传入，无结果返回。
• 供给型接口：无参数传入，但是有返回值
• 判断型接口：有参传入，但是返回值类型是boolean结果。
• 功能型接口：既有参数传入又有结果值返回

四种函数式接口的用法简单举例如下：

/**
 * 内置最常用的四种函数式接口
 */
class FunctionalnterfaceTest{
    //消费型接口
    public void test0(){
        Consumer<String> consumer = s -> System.out.println("[Consumer<T>]--->" + s);
        consumer.accept("hello");
    }
    //供给型接口
    public void test1() {
        Supplier<String> supplier = () ->  "hello";
        System.out.println("[Supplier<T>]--->" + supplier.get());
    }
    //判断型接口
    public void test2() {
        Predicate<String> predicate = s -> s.equals("hello");
        System.out.println("[Predicate<T>]--->" + predicate.test("hello"));
    }
    //功能性接口
    public void test3() {
        Function<String, String> function = (s) -> {
            return "hello" + s;
        };
        System.out.println("[Function<T, R>]--->" + function.apply("666"));
    }
}
public class FunctionalnterfaceExample {
    public static void main(String[] args) {
        FunctionalnterfaceTest functionalnterfaceTest = new FunctionalnterfaceTest();
        functionalnterfaceTest.test0();
        functionalnterfaceTest.test1();
        functionalnterfaceTest.test2();
        functionalnterfaceTest.test3();
    }
}

**【运行结果】** [Consumer]—->hello [Supplier]—->hello [Predicate]—->true [Function]—->hello666

其实，这四种函数式接口每种都有其变种形式，如消费型接口有如下几种形式：

package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Predicate<T> {
    // 在给定的参数上评估这个谓词
    boolean test(T t);
    // 返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑AND
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    // 返回表示此谓词的逻辑否定的谓词,相当于not
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    // 返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑或
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    // 返回根据 Objects.equals(Object, Object)测试两个参数是否相等的谓词
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object);
    }
}
public static void main(String[] args) {
    // 可以构造复杂的条件：并且and、或者or、否negate
    String email = "mengday@gmal.com";
    Predicate<String> predicate = (str) -> str.length() > 20;
    // 测试 emial.length > 0 的boolean
    boolean result = predicate.test(email); // false
    // 测试 !(emial.length > 0) 的boolean
    result = predicate.negate().test(email); // true
    Predicate<String> orPredicate = (str) -> str.contains("@");
    // 测试 emial.length > 0 or emial.contains("@")
    result = predicate.or(orPredicate).test(email); // true
}

自带接口示例

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    // 其它static、default方法
}
public class Main {
    public static void sayHello(IHello iHello, String name) {
        iHello.sayHello(name);
    }
    public static void main(String[] args) {
        IHello iHello = name -> {
            String content = name + ": " + "happy new year everyone!";
            System.out.println(content);
        };
        // 这里可以把iHelo看成一个匿名实现类来传递参数
        sayHello(iHello, "mengday");
        // 如果去掉变量的接收，直接将Lambda表达式传递到参数中，此时Lambda表达式更像是一个函数
        // 也就是说JDK1.8竟然可以将一个函数作为参数传递到方法中，这是之前版本做不到的
        // 将函数作为方法的参数传递，一般用于回调函数，将回调函数传递到方法中
        sayHello(name -> {
            String content = name + ": " + "happy new year everyone!";
            System.out.println(content);
        }, "mengday");
    }
}

练习示例

public class Test {
    public static void main(String[] args) {
        Predicate<Integer> predicate = x -> x > 185;
        Student student = new Student("9龙", 23, 175);
        System.out.println(
            "9龙的身高高于185吗？：" + predicate.test(student.getStature()));
        Consumer<String> consumer = System.out::println;
        consumer.accept("命运由我不由天");
        Function<Student, String> function = Student::getName;
        String name = function.apply(student);
        System.out.println(name);
        Supplier<Integer> supplier = 
            () -> Integer.valueOf(BigDecimal.TEN.toString());
        System.out.println(supplier.get());
        UnaryOperator<Boolean> unaryOperator = uglily -> !uglily;
        Boolean apply2 = unaryOperator.apply(true);
        System.out.println(apply2);
        BinaryOperator<Integer> operator = (x, y) -> x * y;
        Integer integer = operator.apply(2, 3);
        System.out.println(integer);
        test(() -> "我是一个演示的函数式接口");
    }
    /**
    * 演示自定义函数式接口使用
    *
    * @param worker
    */
    public static void test(Worker worker) {
        String work = worker.work();
        System.out.println(work);
    }
    public interface Worker {
        String work();
    }
}
//9龙的身高高于185吗？：false
//命运由我不由天
//9龙
//10
//false
//6
//我是一个演示的函数式接口

Lambda常用示例

方法引用

普通方法的引用

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

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

public class TestSample1 {
    public static void main(String[] args) {
        ReturnOneParam lambda1 = a -> doubleNum(a);
        System.out.println(lambda1.method(3));
        //lambda2 引用了已经实现的 doubleNum 方法
        ReturnOneParam lambda2 = TestSample1::doubleNum;
        System.out.println(lambda2.method(3));
        TestSample1 exe = new TestSample1();
        //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;
    }
}

构造方法的引用

一般我们需要声明接口，该接口作为对象的生成器，通过 类名::new 的方式来实例化对象，然后调用方法返回对象。

public class TestSample2 {
    public static void main(String[] args) {
        ItemCreatorBlankConstruct creator = () -> new Item();
        Item item = creator.getItem();
        ItemCreatorBlankConstruct creator2 = Item::new;
        Item item2 = creator2.getItem();
        ItemCreatorParamContruct creator3 = Item::new;
        Item item3 = creator3.getItem(112, "鼠标", 135.99);
    }
}

lambda 表达式创建线程

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

public class TestSample3Thread {
    public static void main(String[] args) {
        //通过使用匿名类创建线程
        Thread myThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(2 + ":" + i);
                }
            }
        });
        myThread.start();
        //简化方式
        Thread myThread2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(2 + ":" + i);
            }
        });
        myThread2.start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(2 + ":" + i);
            }
        }, "myThread").start();
    }
}

集合操作

遍历集合

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

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

public class TestSample4Collection {
    public static void main(String[] args) {
        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 为我们提供的一个函数式接口，可以简化程序的编写。

public class TestSample4CollectionDel {
    public static void main(String[] args) {
        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 表达式来简化代码。

public class TestSample4CollectionSort {
    public static void main(String[] args) {
        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);
    }
}

Lambda表达式中的闭包问题

这个问题我们在匿名内部类中也会存在，如果我们把注释放开会报错，告诉我 num 值是 final 不能被改变。这里我们虽然没有标识 num 类型为 final，但是在编译期间虚拟机会帮我们加上 final 修饰关键字。

public class Main {
    public static void main(String[] args) {
        int num = 10;
        Consumer<String> consumer = ele -> {
            System.out.println(num);
        };
        //num = num + 2;
        consumer.accept("hello");
    }
}

修改Lambda表达式中的变量值
使用 Java AtomicInteger 和数组修改 Lambda 表达式中的变量值
Java 8语言规范§15.27.2提出了上述问题：

使用任何 lambda 表达式外部声明的局部变量、形式参数或异常参数 必须声明为 final或 effective final 变量(§4.12.4)， 否则会报告编译错误。

3种方案：

1. 使静态变量
2. 使用数组
3. AtomicInteger

优缺点

优点

1. 简化了函数式接口匿名内部类的语法。
2. 使用Lambda表达式可以让我们的代码更少，看上去更简洁，代码更加灵活。

缺点

1. 调试运行和后期维护比较麻烦；
2. 开发目前还是习惯普通的方式Stream+Lambda表达式容易看晕；

mybatis

总结

刻意练习

Stream+Lambda JDK