四大内置核心函数式接口

Java内置的函数式接口是为了方便开发者使用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));
    }
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

• Predicate<T>:断言型(判断型)接口：(有一个泛型的输入参数，返回一个bool值)

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

从上面四个接口的源码中可以看到，接口中不一定只有一个方法的才是函数式接口，一个接口是函数接口的充要条件是有且仅有一个抽象方法。接口中的其他方法可以通过加上default关键字提供默认实现，或者是一个static修饰的静态方法。

四大内置核心函数式接口使用方法。

public class TestLambda2 {
    //Consumer<T>消费型接口:（无返回值，有一个泛型的输入参数）
    @Test
    public void test1() {
        happy(10000, money -> System.out.println("发了" + money + "元工资，开心啊"));
    }
    //处理一个数据
    public void happy(double money, Consumer<Double> consumer) {
        consumer.accept(money);
    }

    //供给型接口(无输入参数，有一个泛型的返回值)
    @Test
    public void test2(){
        getNumList(10, () -> (int) (Math.random() * 100)).forEach(System.out::println);
    }
    //获取一个整数集合
    public List<Integer> getNumList(int num, Supplier<Integer> supplier) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(supplier.get());
        }
        return list;
    }

    //Function<T,R>函数型接口（有一个泛型的输入参数和一个泛型的返回值）
    @Test
    public void test3(){
        System.out.println(strHandler("\t\n    " + "  你好啊！！！哈哈   \r\n\t", String::trim));
    }
    //处理字符串后返回
    public String strHandler(String str, Function<String, String> function) {
        return function.apply(str);
    }

    //Predict<T> 断言型(判断型)接口：(有一个泛型的输入参数，返回一个bool值)
    @Test
    public void test4(){
        List<String> list = Arrays.asList("Hello","what","is","your","name");
        filterStr(list, s -> s.length() > 3).forEach(System.out::println);
    }
    //将满足条件的字符串，放入集合中
    public List<String> filterStr(List<String> list, Predicate<String> predicate) {
        List<String> strings = new ArrayList<>();
        list.forEach(s -> {
            if (predicate.test(s)) {
                strings.add(s);
            }
        });
        return strings;
    }
}

上述代码中使用了方法引用。即需要提供一个函数式接口的地方，不仅可以使用Lambda表达式，还可以使用函数的引用，只需要该函数的输入参数和返回值与函数式接口中的抽象方法一致即可。例如上述代码中的String::trim以及System.out::println。

扩展接口

如果上述四大接口不能满足需求，还有其他一些内置接口可以选用，具体如下，就不一一列举了其使用方法了。

其他函数式接口