java函数式接口高级用法

方法引用

Java 8中提供了方法引用的语法，可以让我们更方便地使用函数式接口。方法引用就是将方法的引用作为值传递给函数式接口。

举个例子，假设我们有一个接口：

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}

我们可以使用lambda表达式来实现这个接口：

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);

但是，Java 8提供了一种更短的方式来实现这个接口，那就是使用方法引用：

Converter<String, Integer> converter = Integer::valueOf;

Lambda表达式的复合

Java 8中提供了andThen和compose方法，用于将多个lambda表达式组合起来。

andThen方法会先执行调用者的lambda表达式，然后再执行参数的lambda表达式。例如：

Function<Integer, Integer> add1 = x -> x + 1;
Function<Integer, Integer> multiply2 = x -> x * 2;
Function<Integer, Integer> add1AndMultiply2 = add1.andThen(multiply2);

int result = add1AndMultiply2.apply(2); // (2 + 1) * 2 = 6

compose方法与andThen方法相反，它会先执行参数的lambda表达式，然后再执行调用者的lambda表达式。

类型推断

Java 8中增强了类型推断，可以让我们更方便地使用函数式接口。

例如，假设我们有一个接口：

@FunctionalInterface
interface MyFunction<T> {
    T apply(T t1, T t2);
}

我们可以使用Java 8的类型推断功能来创建MyFunction实例：

MyFunction<Integer> add = (a, b) -> a + b;
MyFunction<Integer> subtract = (a, b) -> a - b;
MyFunction<Integer> multiply = (a, b) -> a * b;

默认方法

Java 8中，接口可以包含默认方法。默认方法是接口的一种实现方式，可以让我们在不破坏接口原有结构的情况下，给接口添加新的方法。

例如，假设我们有一个接口：

@FunctionalInterface
interface MyFunction<T> {
    T apply(T t1, T t2);

    default MyFunction<T> andThen(MyFunction<T> after) {
        Objects.requireNonNull(after);
        return (T t1, T t2) -> after.apply(apply(t1, t2), t2);
    }
}

这个接口包含一个默认方法andThen，它接受另一个MyFunction实例作为参数，然后返回一个新的MyFunction实例，该实例会先执行调用者的apply方法，然后再执行参数的apply方法。

静态方法

Java 8中，接口也可以包含静态方法。静态方法是接口的一种实现方式，可以让我们在接口中定义一些通用的工具方法。

例如，假设我们有一个接口：

@FunctionalInterface
interface MyFunction<T> {
    T apply(T t1, T t2);

    static <T> MyFunction<T> identity() {
        return (t1, t2) -> t1;
    }
}

这个接口包含一个静态方法identity，它返回一个MyFunction实例，该实例会把第一个参数返回。这个方法在函数式编程中比较常用，因为它可以作为一个默认的转换器，例如：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<String> strings = numbers.stream()
        .map(MyFunction.identity())
        .map(String::valueOf)
        .collect(Collectors.toList());

Supplier接口

Java 8中提供了一个新的函数式接口Supplier，它表示一个供应商，用于提供一个值。Supplier接口只包含一个方法get，它不接受任何参数，返回一个值。

例如，假设我们有一个Supplier接口：

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

我们可以使用lambda表达式来实现这个接口：

MySupplier<String> supplier = () -> "Hello, world!";
String result = supplier.get();

Consumer接口

Java 8中提供了一个新的函数式接口Consumer，它表示一个消费者，用于消费一个值。Consumer接口只包含一个方法accept，它接受一个参数，不返回任何值。

例如，假设我们有一个Consumer接口：

@FunctionalInterface
interface MyConsumer<T> {
    void accept(T t);
}

我们可以使用lambda表达式来实现这个接口：

MyConsumer<String> consumer = (s) -> System.out.println(s);
consumer.accept("Hello, world!");

Predicate接口

Java 8中提供了一个新的函数式接口Predicate，它表示一个谓词，用于判断一个值是否满足某个条件。Predicate接口只包含一个方法test，它接受一个参数，返回一个boolean值。

例如，假设我们有一个Predicate接口：

@FunctionalInterface
interface MyPredicate<T> {
    boolean test(T t);
}

我们可以使用lambda表达式来实现这个接口：

MyPredicate<Integer> predicate = (i) -> i % 2 == 0;
boolean result = predicate.test(4); // true