Java中的匿名函数使用：Lambda表达式和函数式接口

在Java中，匿名函数是指没有名字的函数。这种函数通常在需要将某个代码块作为参数传递给另一个函数或者用于代替函数的返回值的时候使用。

Java 8 引入了 Lambda 表达式和函数式接口的概念，这两个特性使得在 Java 中使用匿名函数更加方便。下面将对这两种特性进行详细的介绍。

Lambda 表达式

Lambda 表达式是一种简洁的语法方法，可以用来表示匿名函数。在 Java 中，Lambda 表达式可以被用于任何函数式接口中。函数式接口是指只有一个抽象方法的接口，可以用 @FunctionalInterface 注解来标识。

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

(parameter1, parameter2, …) -> {statement1; statement2; …}

其中，参数列表可以为空，或者包含一个或多个参数。在参数列表和箭头符号（“->”）之间，需要使用空格分隔。箭头符号表示 Lambda 表达式的参数输入和执行体之间的分割线。

如果有多条语句需要执行，需要使用大括号（“{}”）进行括起来。如果只有一条语句可以省略大括号。

我们可以使用一个例子来说明 Lambda 表达式的使用：

interface MyInterface {
  void display(String msg);
}

public class LambdaExpressionExample {
  public static void main(String[] args) {
    MyInterface myInterface = (msg) -> {
      System.out.println(msg);
    };

    myInterface.display("Hello, Lambda!");
  }
}

在这个例子中，我们定义了一个函数式接口 MyInterface，它只有一个抽象方法 display。然后我们在 main 函数中使用 Lambda 表达式来实现 MyInterface 接口，输出了一个字符串。

函数式接口

函数式接口是指只有一个抽象方法的接口。在 Java 8 之前，Java 中已经存在了许多函数式接口，比如 Runnable 和 Comparable。但是，这些接口只被用于表示一个特定的功能，而没有被设计成通用的函数式接口。

Java 8 引入了许多新的通用函数式接口，比如 Consumer、Supplier、Function、Predicate 等。这些接口都有一些通用的方法，可以被用于方法引用和 Lambda 表达式等操作。

下面是一些常用的函数式接口及其方法：

Consumer<T>: 接受一个输入参数，没有返回值。

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

Supplier<T>: 无参数，返回一个结果。

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

Function<T, R>: 一个输入，一个输出。

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

Predicate<T>: 接受一个输入参数，返回一个布尔值。

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

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

总之，Java 8 通过引入 Lambda 表达式和函数式接口，为 Java 中使用匿名函数带来了更好的支持。Lambda 表达式可以简化代码的实现，而函数式接口则可以让我们更加灵活地使用匿名函数。