一、什么是函数式接口

• 只包含一个抽象方法的接口， 称为函数式接口。
• 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda表达式抛出一个受检异常， 那么该异常需要在目标接口的抽象方法上进行声明）。
• 我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口， 同时 javadoc 也会包含一条声明， 说明这个接口是一个函数式接口。

二、自定义函数式接口

1、普通函数式接口定义

@FunctionalInterface
public interface MyFunInterface {
    String getValue(String value);
}

2、带泛型的函数式接口定义

@FunctionalInterface
public interface MyFunInterface<T> {
    T getValue(T t);
}

三、函数式接口作为参数

1、方法定义

public String getFormatValue(MyFunInterface<String> myFunInterface, String value) {
    return myFunInterface.getValue(value);
}

2、调用传参（参数传递Lambda表达式）

String upperValue = getFormatValue(str -> str.toUpperCase(), "hello world");
System.out.println(upperValue);

3、输出结果：

4、说明：

为了将 Lambda 表达式作为参数传递， 接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。

四、Java 内置四大核心函数式接口

1、Consumer<T>消费型接口举例：

/**
 * 定义消费方法
 *
 * @param money    消费金额
 * @param consumer Consumer函数式接口
 */
public void consumerMethod(double money, Consumer<Double> consumer) {
    consumer.accept(money);
}

/**
 * Consumer<T> 消费型接口测试
 */
public void testConsumer() {
    consumerMethod(2000, money -> System.out.println("您好，本次合计消费：" + money + "元"));
}

测试结果：

2、Supplier<T>供给型接口举例：

/**
 * 随机产生指定个数的整数，并放入集合中
 *
 * @param num 指定的个数
 * @param sup Supplier函数式接口
 * @return 结果集
 */
public List<Integer> getNumList(int num, Supplier<Integer> sup) {
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < num; i++) {
        Integer n = sup.get();
        list.add(n);
    }
    return list;
}

/**
 * Supplier<T> 供给型接口测试
 */
public void testSupplier() {
    List<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100));
    for (Integer num : numList) {
        System.out.println(num);
    }
}

测试结果：

3、Function<T, R>函数型接口举例：

/**
 * 处理字符串
 *
 * @param str 需要处理的字符串
 * @param fun 处理方式（Function函数式接口）
 * @return 处理之后的字符串
 */
public String strHandler(String str, Function<String, String> fun) {
    return fun.apply(str);
}

/**
 * Function<T, R> 函数型接口测试
 */
@Test
public void testFunction() {
    // 去除字符串首尾空格
    String newValue = strHandler("\t\t\t Hello World  ", value -> value.trim());
    System.out.println(newValue);

    // 截取字符串
    String subValue = strHandler("Hello World", value -> value.substring(6));
    System.out.println(subValue);
}

测试结果：

4、Predicate<T>断定型接口举例：

/**
 * 过滤字符串，将满足条件的字符串，放入集合中
 *
 * @param list 集合
 * @param pre  判断方式（Predicate函数式接口）
 * @return 结果集
 */
public List<String> filterStr(List<String> list, Predicate<String> pre) {
    List<String> strList = new ArrayList<>();
    for (String str : list) {
        if (pre.test(str)) {
            strList.add(str);
        }
    }
    return strList;
}

/**
 * Predicate<T> 断言型接口测试
 */
@Test
public void test4() {
    List<String> list = Arrays.asList("Hello", "World", "Lambda", "www", "ok");
    // 过滤长度大于3的字符串
    List<String> strList = filterStr(list, (s) -> s.length() > 3);
    for (String str : strList) {
        System.out.println(str);
    }
}

测试结果：

五、其他内置函数式接口