函数式接口

定义

函数式接口就是只定义一个抽象方法的接口，接口现在还可以拥有默认方法（即在类没有对方法进行实现时，其主体为方法提供默认实现的方法）。哪怕有很多默认方法，只要接口只定义了一个抽象方法，它就仍然是一个函数式接口。

@FunctionalInterface
public interface MathOperation {
    int operation(int a, int b);

    default void print(){
        System.out.println("我是接口默认方法!");
    }
}

常用的函数式接口

Predicate

java.util.function.Predicate接口定义了一个名叫test的抽象方法，它接受泛型T对象，并返回一个boolean。

 public static void main(String[] args) {
        Predicate<String> nonEmptyStringPredicate = (s -> !s.isEmpty());
        filter(Arrays.asList("string"),nonEmptyStringPredicate);
    }
    public static <T> List<T> filter(List<T> list, Predicate<T> p) {
        List<T> results = new ArrayList<>();
        for(T s: list){
            if(p.test(s)){
                results.add(s);
            }
        }
        return results;
    }

Consumer

java.util.function.Consumer定义了一个名叫accept的抽象方法，它接受泛型T的对象，没有返回（void）。

  public static void main(String[] args) { 
        //方法引用
        Consumer<Integer> c = System.out::println;
        forEach(Arrays.asList(1,2,3), c);
    }
    public static <T> void forEach(List<T> list, Consumer<T> c) {
       for (T i : list) {
           c.accept(i);
       }
    }

Function

java.util.function.Function<T, R>接口定义了一个叫作apply的方法，它接受一个泛型T的对象，并返回一个泛型R的对象。如果你需要定义一个Lambda，将输入对象的信息映射到输出，就可以使用这个接口。

 public static void main(String[] args) {
        Function<String, Integer> f = String::length;
        List<Integer> l = map(Arrays.asList("lambda","in"), f);
        //List<Integer> l = map(Arrays.asList("lambda","in"), (String s) -> s.length());
    }
    public static <T, R> List<R> map(List<T> list, Function<T,R> f) {
       List<R> result = new ArrayList<>();
       for (T s : list) {
           result.add(f.apply(s));
       }
       return result;
    }

函数式接口整理

为了避免装箱操作，对Predicate和Function<T, R>等通用函数式接口的原始类型：IntPredicate、IntToLongFunction等。

函数式接口	函数描述符
Predicate	T->boolean
Consumer	T->void
Function<T, R>	T->R
Supplier	()->T
UnaryOperator	T->T
BinaryOperator	(T,T)->T
BiPredicate<L,R>	(L,R)->boolean
BiConsumer<T,U>	(T,U)->void
BiFunction<T,U,R>	(T,U)->R