仓库源文，站点原文

layout: post title: "Java8新特性之Lambda表达式" categories: Java tags: Java8 Lambda

author: 张乘辉

• content {:toc} 前面的文章很多都用到了Lambda表达式，Lambda表达式是一种函数式编程的风格，以前我们是这样实现多线程编程的：

new Thread(new Runnable(){
  public void run(){
    System.out.println("帅比辉");
  }
};
).start();

如上，用到了匿名内部类，但这样做会造成代码重复率多，且臃肿，不易阅读，我们通过Lambda表达式改进一下：

new Thread(() -> {
  System.out.println("傻比罗");
}).start();

函数式接口

想要用Lambda表达式需要满足方法参数需要是一个接口类型的参数，比如Thread的构造方法的参数就是一个Runnable接口，且接口只能有一个需要实现的方法，Runnable接口只有一个实现方法run()，Java8本身提供了很多这种函数式接口，如：

• Predicate 接口只有一个参数，返回boolean类型。该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）：

// 源码
@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

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

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

Predicate<String> p = (s) -> s.length() > 0;

• Function接口有一个参数并且返回一个结果，并附带了一些可以和其他函数组合的默认方法（compose, andThen）：

// 源码
@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

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

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

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

Function<String, Integer> toInteger = (s) -> Integer.valueOf(s);
Function<String, String> backToString = toInteger.andThen((i) -> String.valueOf(i));
backToString.apply("123");

• Supplier接口返回一个任意范型的值，和Function接口不同的是该接口没有任何参数：

// 源码
@FunctionalInterface
public interface Supplier<T> {
    T get();
}

Supplier<String> supplier = () -> "帅比辉";

• Consumer接口表示执行在单个参数上的操作：

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("傻狗", "罗小狗"));

Java8自带还有很多这样的函数式接口，这里就不一一介绍了。

我们也可以自定以一个函数式接口：

@FunctionalInterface
public interface MyFunction<T> {
    T get(T t);
}

MyFunction<Integer> function = (t) -> 100 * t;

语法

从上面例子中可看到，Lambda表达式的基本语法：

(parameters) -> expression

或者是语句块：

(parameters) -> { statements; }

lambda表达式的语法由参数列表、箭头符号->和函数体组成，而函数体可以是表达式也可以是语句块，其中，parameters表示接口方法的参数，如果没有指定类型，会根据上下文自动推断其类型：

• 表达式：可以被执行并返回其结果值，这相当于默认是匿名方法中return的内容；
• 语句块：按顺序执行语句块中的内容，如果有return返回值，则会交给匿名方法去调用。

现在我们知道了其实Lambda表达式就是简便了我们实现接口（该接口只能有一个抽象方法）的写法而已。

方法引用

其实把Function那个实例改成方法引用更为恰当：

Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123");

方法引用又是Lambda表达式的一种简化写法，其基本写法是左边是类名称，右边是方法，主要分为：

1. 方法引用：ClassName::methodName
2. 构造方法引用：Class::new