FunctionalInterface 函数式接口

• 函数式接口：仅仅包含一个抽象方法的接口
• 由于默认方法不是抽象方法，因此函数式接口可以包含多个默认方法
• 可以将 Lambda 表达式理解为函数式接口，但是 Lambda 表达式不能访问默认方法

使用：

public class FunctionalInterfaceTest {
    public static void main(String[] args) throws Exception {
        // 可以理解为定义了一个匿名类，实现了该函数式接口
        MyConverter<String, Integer> mc = (from) -> Integer.valueOf(from);
        System.out.println(mc.convert("123"));

        MyConverter<String, Integer> another = (from) -> {return Integer.valueOf(from);};
        System.out.println(another.convert("123"));
    }
}

// 函数式接口，仅仅包含一个抽象方法
@FunctionalInterface
interface MyConverter<F, T> {
    T convert(F from);
}

方法引用

Java8 允许使用 :: 来传递方法的引用或构造函数的引用。
方法引用的唯一用途是支持 Lambda 的简写，使用方法名称来表示 Lambda。

• 方法的引用，例如，上述的例子还可以进行如下的简化：

MyConverter<String, Integer> mc = Integer::valueOf;
System.out.println(mc.convert("123"));

• 构造函数的引用，使用 new 关键字，例如使用 String 来构造一个 Integer：

public class FunctionalInterfaceTest {
    public static void main(String[] args) throws Exception {
        MyBuilder<Integer> mb = Integer::new;
        System.out.println(mb.build("123"));
    }
}

@FunctionalInterface
interface MyBuilder<F> {
    F build(String s);
}

Java8 内建的函数式接口，所在包 java.util.function

• interface Predicate<T>
  • 抽象方法：boolean test(T t); 一个参数，返回 boolean
  • 使用：

Predicate<Integer> p = (i) -> i > 100;
System.out.println(p.test(200));

• interface Function<T, R>
  • 抽象方法：R apply(T t); 一个参数，返回一个结果
  • 使用：

Function<Integer, Integer> f = (i) -> (i + 1);
System.out.println(f.apply(123));

• interface Supplier<T>
  • 抽象方法：T get(); 无参数，返回一个结果
  • 使用：

Supplier<Integer> s = () -> 123;
System.out.println(s.get());

• interface Consumer<T>
  • 抽象方法：void accept(T t); 一个参数，无返回
  • 使用：

Consumer<Integer> c = (i) -> System.out.println(i);
c.accept(123);

• interface Comparator<T>
  • 抽象方法： int compare(T o1, T o2); 两个参数，返回 int
  • 使用：

Comparator<Integer> com = (i1, i2) -> i1.compareTo(i2);
System.out.println(com.compare(1, 2));