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类中的方法除外）的接口是函数式接口

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

1. 只能有一个抽象方法，没有抽象方法或者有多个抽象方法的接口都不是函数式接口。
2. 必须是抽象方法，如果接口里面只有一个静态方法或者default方法，都不是函数式接口。
3. 如果接口里面只有一个抽象方法，但是这个抽象方方法是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 numbers = Arrays.asList(5, 2, 22, 13, 9, 10, 1);
        Collections.sort(numbers, new Comparator() {
            @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常见的函数式接口

1. Runable/Callable/Comparator 等

2. java.util.function包下的一系列函数式接口

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

2.2 示例

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

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

示例代码：

        Callable c1 = new Callable() {
            @Override
            public String call() throws Exception {
                return "Call 1";
            }
        };
        Callable 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
下面是Consumer 的接口声明,其方法是有参数无返回值的

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

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

示例代码:

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

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

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

    default  Function compose(Function var1) {
        Objects.requireNonNull(var1);
        return (var2) -> {
            return this.apply(var1.apply(var2));
        };
    }

    default  Function andThen(Function var1) {
        Objects.requireNonNull(var1);
        return (var2) -> {
            return var1.apply(this.apply(var2));
        };
    }

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

示例代码:

        // Function 有参有返回值
        Function f1 = new Function() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        };
        Function f2 = s -> s.length();
        System.out.println(f1.apply("hello java"));
        System.out.println(f2.apply("hello lambda"));

根据之前的两个例子，这个示例也十分好理解，由于apply只有参数，写一个s就可以了，由于方法的实现体中代码十分简单，所以省略了{}和return。当然，如果方法的实现体比较复杂，我们就没有办法省略了，比如下面这种：

        // Function2
        Function f3 = a -> {
            int sum = 0;
            for (int i = 1; i <= a; i++) {
                sum += i;
            }
            return sum;
        };
        System.out.println(f3.apply(100));

下篇：Java Lambda表达式之方法引用