常用函数式接口

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

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

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

Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate); 

Consumer
java.util.function.Consumer<T>定义了一个名叫accept的抽象方法，它接受泛型T的对象，没有返回（void）。你如果需要访问类型T的对象，并对其执行某些操作，就可以使用这个接口。例如，可以创建一个ForEach方法

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

public static <T> void forEach(List<T> list, Consumer<T> c){ 
      for(T i: list){
           c.accept(i);
      }
} 

forEach(
         Arrays.asList(1,2,3,4,5),
         (Integer i) -> System.out.println(i)
       ); 

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

@FunctionalInterface
public interface Function<T, R>{
     R apply(T t);
}

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;
}
// [7, 2, 6]
List<Integer> l = map(
                     Arrays.asList("lambdas","in","action"),
                     (String s) -> s.length()
 );