Lambda表达式

函数式接口

Predicate

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
...
}

可以看到实际上Predicate只有一个需要显示实现的方法，所以可以用@FunctionalInterface，它是一个函数式接口。

示例

public class Bear {

    private String color;

    public Bear(String color) {
        this.color = color;
    }

    public static List<Bear> filter(List<Bear> bears, Predicate<Bear> predicate) {
        List<Bear> bears1 = new ArrayList<>();
        for (Bear bear : bears) {
            if (predicate.test(bear)) {
                bears1.add(bear);
            }
        }
        return bears1;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    
    public static void main(String[] args) {
        filter(List.of(new Bear("green"), new Bear("red")), (Bear b) -> b.getColor().equals("red"));
    }
}

Consumer

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
...
}

Consumer翻译就是消费者了，所以可以理解为这个接口的作用是消费对象，因此可以看到它是void的

示例

public class Bear {

    private String color;

    public Bear(String color) {
        this.color = color;
    }

    public static List<Bear> forEach(List<Bear> bears, Consumer<Bear> consumer) {
        List<Bear> bears1 = new ArrayList<>();
        for (Bear bear : bears) {
            consumer.accept(bear);
        }
        return bears1;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public static void main(String[] args) {
        forEach(List.of(new Bear("green"), new Bear("red")), 
                (Bear bear) -> System.out.println(bear.getColor()));
    }
}

Function

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
...
}

这个接口就是接受一个T类型的对象，映射返回一个R类型的对象。

示例

public class Bear {
    public static <T, R> List<R> map(List<T> bears, Function<T, R> function) {
        List<R> list = new ArrayList<>();
        for (T t : bears) {
            list.add(function.apply(t));
        }
        return list;
    }

    public static void main(String[] args) {
        List<Integer> list = map(List.of("aa", "aas", "sssss"), (String s) -> s.length());
        list.stream().forEach((s) -> System.out.println(s.intValue()));
    }
}

以上是三个标准的泛型化接口，为什么要设计成引用类型呢，因为泛型不允许和原始类型一块使用。当然这个问题也不是这么简单的解释。

类型推断

list.stream().forEach(s -> System.out.println(s.intValue()));

这行代码并没有定义s的类型，但是它是会进行上下文判断的。

使用局部变量

        int num = 22;
        Runnable r = () -> System.out.println(num);　　　　　　　ok

        int num = 22;
        Runnable r = () -> System.out.println(num++);　　　　　　error

        int num = 22;
        Runnable r = () -> System.out.println(num);　　　　　　　　error
        num++;

lambda中是不允许修改其引用值的。

实际上我之前研究过，此处就是单纯的copy by value， not copy by reference.对比其它的语言，这无疑是一大败笔，当然会改善，但是不知道什么时候，希望尽快，它是个灾难。

lambda可以没有限制的捕获实例变量或者静态变量，但是局部变量必须显示的声明为final，或者不声明但是实际上是final，lambda捕获的局部变量必须是最后一次赋值完成的。

方法引用

inventory.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight())); 

inventory.sort(comparing(Apple::getWeight)); 

 方法引用的三类：

指向静态方法的引用：Integer中的parseInt方法，写作Integer::parseInt

指向任意类型实例方法的方法引用：String::length

指向现有对象的实例方法引用：下面分析

第二种就是你在引用对象的方法，比如，(String s) -> s.toUpperCase()就可以写成 String::toUpperCase

第三种就是调用外部对象的方法，比如 () -> expenseiveTransaction.getValue() 就可以写成 expensiveTransaction::getValue,  这种也是较为常用的

举个常用的例子，比如你要对List<String>进行排序，可以这样:

        List<String> list = Arrays.asList("a", "v", "c");
        list.sort((s1, s2) -> s1.compareToIgnoreCase(s2));

也可以只方法引用：

        list.sort(String::compareToIgnoreCase);

构造函数引用

        Supplier<Apple> c1 = () -> new Apple();
        Apple apple = c1.get();

等效于：

        Supplier<Apple> c1 = Apple::new;
        Apple apple = c1.get();

多参数的构造器

        BiFunction<String, Integer, Apple> c1 = (color, weight) -> new Apple(color, weight);　　　　　　这里一个细节就是你需要将要创建的对象放在泛型的尾部
        BiFunction<String, Integer, Apple> c2 = Apple::new;

一个示例应用，大概就是根据苹果类型和重量新建苹果对象

    public Apple(int weight) {
        this.weight = weight;
    }

    static Map<String, Function<Integer, Apple>> map = new HashMap<>();
    static {
        map.put("apple1", Apple::new);
        map.put("apple2", Apple::new);
    }
    public static Apple giveMeApple(String appleType, Integer weight) {
        return map.get(appleType.toLowerCase()).apply(20);
    }

复合Lambda表达式

比较器复合

逆序

        apples.sort(Comparator.comparing(Apple::getWeight).reversed());

比较器链

        apples.sort(Comparator.comparing(Apple::getWeight)
                .reversed()
                .thenComparing(Apple::getColor)　　　　// 如果两个Apple一样重，那么再比较颜色，当然这里用颜色比较是不合适的
        );

谓词复合

函数复合

    public static void main(String[] args) {
        Function<Integer, Integer> f = x -> x + 1;
        Function<Integer, Integer> g = x -> x * 2;
        Function<Integer, Integer> h = f.andThen(g);
        System.out.println(h.apply(1));
    }
输出4

andThen实际上是 g(f(x))

    public static void main(String[] args) {
        Function<Integer, Integer> f = x -> x + 1;
        Function<Integer, Integer> g = x -> x * 2;
        Function<Integer, Integer> h = f.compose(g);
        System.out.println(h.apply(1));
    }
输出3

compose实际上是f(g(x))

 这种函数复合有什么用呢？

小结

 

 《Java8实战》