函数式接口

函数式接口定义且只定义了一个抽象方法。函数式接口很有用，因为抽象方法的签名可以描述Lambda表达式的签名。函数式接口的抽象方法的签名称为函数描述符。所以为了应用不同的Lambda表达式，你需要一套能够描述常见函数描述符的函数式接口。

Java API中已经有了几个函数式接口

Predicate

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

  @FunctionalInterface
        public interface Predicate {
            boolean test(T t);
        }
        public static  List < T > filter(List < T > list, Predicate < T > p) {
            List results = new ArrayList<>();
            for (T s : list) {
                if (p.test(s)) {
                    results.add(s);
                }
            }
            return results;
        }
        Predicate nonEmptyStringPredicate = (String s) -> !s.isEmpty();
        List nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);

Consumer

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

        @FunctionalInterface
        public interface Consumer {
            void accept(T t);
        }
        public static  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接口定义了一个叫作apply的方法，它接受一个
泛型T的对象，并返回一个泛型R的对象。如果你需要定义一个Lambda，将输入对象的信息映射到输出，就可以使用这个接口（比如提取苹果的重量，或把字符串映射为它的长度）。

        @FunctionalInterface
        public interface Function {
            R apply(T t);
        }
        public static  List < R > map(List < T > list,
                Function < T, R > f) {
            List result = new ArrayList<>();
            for (T s : list) {
                result.add(f.apply(s));
            }
            return result;
        }
// [7, 2, 6] 
        List l = map(
                Arrays.asList("lambdas", "in", "action"),
                (String s) -> s.length()
        );