Java Lambda表达式简介及入门

1.Lambda表达式简介

lambda表达式是Java 1.8推出的，距离现在已经有六年多的时间，笔者主要从事Android Framework相关的工作，Android 从7.0开始编译环境依赖jdk 1.8以来，Android原生源码中使用Lambda表达式的地方也越来越多。不管是为了看懂代码，还是为了更好的写代码，了解Lambda表达式是Java开发中必不可少的。虽然本文的示例代码工程是Android Studio工程，但是示例代码并没有使用到Android特性，不需要Android相关的知识。

代码下载

1.1 什么是Lambda表达式

Lambda表达式是 Java8 中最重要的新功能之一。使用 Lambda 表达式可以替代只有一个抽象函数的接口实现，告别匿名内部
类，代码看起来更简洁易懂。Lambda表达式同时还提升了对集合、框架的迭代、遍历、过滤数据的操作。

可见Lambda表达式的使用场景是替代“只有一个抽象函数的接口”的实现。
只有一个抽象函数的接口在Java 1.8中有个特定名称"函数式接口"

1.2 什么是函数式接口

只有一个 抽象方法 （Object类中的方法除外）的接口是函数式接口

对于函数式接口的定义，有三点需要注意

只能有一个抽象方法，没有抽象方法或者有多个抽象方法的接口都不是函数式接口。
必须是抽象方法，如果接口里面只有一个静态方法或者default方法，都不是函数式接口。
如果接口里面只有一个抽象方法，但是这个抽象方方法是Object类中的方法，如hashCode方法，这个接口也不是函数式接口。
根据以上几点，下面的接口是函数式接口:

    //是函数式接口
    @FunctionalInterface
    interface LambdaInterface01 {
        int test01();
    }

以下的接口不是函数式接口

    //不是函数式接口
    //@FunctionalInterface
    interface LambdaInterface02 {
        default int test02() {
            return 100;
        }

        static int test03() {
            return 99;
        }
    }

    //不是函数式接口
    //@FunctionalInterface
    interface LambdaInterface03 {
        int hashCode();
    }

在java 1.8中，如果是函数式接口，可以添加@FunctionalInterface注解，不是函数式接口的接口添加该注释，编译器会报错。

1.3 常见的Lambda表达式示例

        //example-1
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread run 1");
            }
        }).start();

        new Thread(() -> System.out.println("thread run 2")).start();

        //example-2
        List<Integer> numbers = Arrays.asList(5, 2, 22, 13, 9, 10, 1);
        Collections.sort(numbers, new Comparator<Integer>() {
            @Override
            public int compare(Integer n1, Integer n2) {
                return n1 - n2;
            }
        });
        System.out.println(numbers);
        numbers = Arrays.asList(5, 2, 22, 13, 9, 10, 1);
        Collections.sort(numbers, (n1, n2) -> n1 - n2);
        System.out.println(numbers);

上面展示了常见的一些lambda表达式，可以得出lambda表达式的一些特点:
1.参数类型自动推断
2.代码量少，简洁
如(n1, n2)自动推断为Integer类型，上面的代码很明显的lambda表达式写的代码只用了一行，传统的写法却要六行。

1.4 Lambda表达式语法

lambda.png

args -> expr
或者
(Object… args) -> {函数式接口抽象方法实现逻辑}
lambda表达式分为三部分，方法参数、lambda操作符和函数式接口方法的实现逻辑。
()里面参数的个数，根据函数式接口里面抽象方法的参数个数来决定。
当只有一个参数的时候，()可以省略
当expr逻辑非常简单的时候，{}和return可以省略

2. Lambda表达式入门

2.1常见的函数式接口

Runable/Callable<V>/Comparator<T> 等
java.util.function包下的一系列函数式接口

Supplier 代表一个输出
Consumer 代表一个输入
BiConsumer 代表两个输入
Function 代表一个输入，一个输出（一般输入和输出是不同类型的）
UnaryOperator 代表一个输入，一个输出（输入和输出是相同类型的）
BiFunction 代表两个输入，一个输出（一般输入和输出是不同类型的）
BinaryOperator 代表两个输入，一个输出（输入和输出是相同类型的）

2.2 示例

选取部分函数式接口进行示例
a. Callable<V>
下面是Callable<V>的接口声明,其方法是无参数有返回值的

@FunctionalInterface
public interface Callable<V> {
   V call() throws Exception;
}

示例代码：

        Callable<String> c1 = new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "Call 1";
            }
        };
        Callable<String> c2 = () -> "Call 2";
        System.out.println(c1.call());
        System.out.println(c2.call());

例子中第一种写法是以前的写法，使用lambda表达式后，由于call方法没有参数，所以lambda表达式的参数部分只要写一个()就可以了，当expr逻辑非常简单的时候，{}和return可以省略，所以lambda表达式的函数式接口方法的实现逻辑直接写了一个"Call 2"，当然如果写成return "Call 2"或者{return "Call 2"}这样的形式也是没有问题的。
b.Consumer<T>
下面是Consumer<T> 的接口声明,其方法是有参数无返回值的

@FunctionalInterface
public interface Consumer<T> {
    void accept(T var1);

    default Consumer<T> andThen(Consumer<? super T> var1) {
        Objects.requireNonNull(var1);
        return (var2) -> {
            this.accept(var2);
            var1.accept(var2);
        };
    }
}

示例代码:

        // Consumer 有参无返回值
        Consumer<String> co1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        Consumer<String> co2 = s -> System.out.println(s);
        co1.accept("Consumer 1");
        co2.accept("Consumer 2");

例子中我们在方法的实现中将接收到的字符串打印出来，例子一是以前的写法，使用lambda表达式后，由于accept方法有参数，所以lambda表达式的参数部分只要写一个(s)就可以了,因为当只有一个参数的时候，()可以省略，所以lambda表达式的参数部分只写了一个s,由于lambda表达式的函数式接口方法的实现逻辑也比较简单，所以也省略了{}。
c. Function<T, R>
下面是Function<T, R> 的接口声明,其方法是有参数有返回值的

@FunctionalInterface
public interface Function<T, R> {
    R apply(T var1);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> var1) {
        Objects.requireNonNull(var1);
        return (var2) -> {
            return this.apply(var1.apply(var2));
        };
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> var1) {
        Objects.requireNonNull(var1);
        return (var2) -> {
            return var1.apply(this.apply(var2));
        };
    }

    static <T> Function<T, T> identity() {
        return (var0) -> {
            return var0;
        };
    }
}