Java的Lambda表达式

转载请注明出处：https://www.cnblogs.com/zhizaixingzou/p/10024036.html

目录

 

1. Lambda表达式

1.1. 实例

接口定义中只能有一个方法。

package com.cjw.knowledge.demo;

public interface MathOperator {
    int operate(int a, int b);
}

使用Lambda表达式可以免去使用匿名类的麻烦，且提供了函数式编程的能力。

package com.cjw.knowledge.demo;

public class Demo {
    public static void main(String[] args) {
        MathOperator adder = (int a, int b) -> a + b;
        System.out.println("3 + 5 = " + adder.operate(3, 5));
    }
}

等价于：

System.out.println("3 + 5 = " + ((MathOperator)((int a, int b) -> a + b)).operate(3, 5));

运行的结果如下。

 

Lambda表达式的语法格式如下：

(parameters) -> expression;

或者

(parameters) -> {statement;}

参数的类型可以不写，编译器可以推断出来。

如果参数只有一个，则参数可不括号括起来，但零个或多个参数需要。

如果主体只有一条语句或者为一个表达式，则可以不写大括号。

1.2. Lambda表达式的定义

Lambda表达式是Java 8最重要的特性。它可以作为方法的参数使用，使得代码更加简洁紧凑，为函数式编程的特征。

Lambda表达式是一个对象，它必须赋给一个函数式接口，这种接口可以通过@FunctionalInterface显式指明，它只能有一个方法。

 

Lambda表达式访问的外部变量必须是final修饰的。当然也可以不用final修饰，但一旦为Lambda表达式使用，则必须不能被修改，否则编译不过。

Lambda表达式中不许声明一个与外部变量同名的参数或局部变量。

 

将常规方法转换为Lambda表达式。

public class Demo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
        list.forEach(n -> System.out.println(n));

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

 

package com.cjw.knowledge.demo;

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

public class Demo {
    public static void main(String[] a) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
        System.out.println("Print all numbers:");
        evaluate(list, (n) -> true);

        System.out.println("Print no numbers:");
        evaluate(list, (n) -> false);

        System.out.println("Print even numbers:");
        evaluate(list, (n) -> n % 2 == 0);

        System.out.println("Print odd numbers:");
        evaluate(list, (n) -> n % 2 == 1);

        System.out.println("Print numbers greater than 5:");
        evaluate(list, (n) -> n > 5);
    }

    public static void evaluate(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer n : list) {
            if (predicate.test(n)) {
                System.out.print(n + " ");
            }
        }
        System.out.println();
    }
}

 

package com.cjw.knowledge.demo;

import java.util.Arrays;
import java.util.List;

public class Demo {
    public static void main(String[] a) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
        list.stream().map((x) -> x * x).forEach(System.out::println);
        System.out.println(list.stream().map(x -> x * x).reduce((x, y) -> x + y).get());
    }
}

 

对于匿名类，关键词 this 解读为匿名类，而对于 Lambda 表达式，关键词 this 解读为写就 Lambda 的外部类。

1.3. 几种常见的Lambda表达式接口

package com.cjw.knowledge.demo;

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

public class Demo {
    // 消费型接口
    public static void donate(Integer money, Consumer<Integer> consumer) {
        consumer.accept(money);
    }

    // 供给型接口
    public static Integer supply(Supplier<Integer> supplier) {
        return supplier.get();
    }

    // 函数型接口
    public static Integer convert(String str, Function<String, Integer> function) {
        return function.apply(str);
    }

    // 断言型接口
    public static List<String> filter(List<String> fruits, Predicate<String> predicate) {
        List<String> f = new ArrayList<>();
        for (String s : fruits) {
            if (predicate.test(s)) {
                f.add(s);
            }
        }
        return f;
    }

    public static void main(String[] args) {
        donate(1000, money -> System.out.println("捐款： " + money + "元"));

        Integer integer = supply(() -> (int) (Math.random() * 100));

        Integer value = convert("28", x -> Integer.parseInt(x));

        List<String> fruits = Arrays.asList("香蕉", "哈密瓜", "榴莲", "火龙果", "水蜜桃");
        List<String> newFruit = filter(fruits, (f) -> f.length() == 2);
    }
}