java.util.function 中的 Function、Predicate、Consumer

函数式接口：

函数式接口（Functional Interface）就是一个有且仅有一个抽象方法，但可以有多个非抽象方法的接口。

函数式接口可以被隐式转换为 Lambda 表达式。

Function 函数

Function 与 BiFunction

输入一个或多个参数，也可以规定返回值类型，并执行一段逻辑

Function<Integer, Integer> function = num -> num + 1;
Function<Integer, Integer> function1 = num -> num * 2;
System.out.println(function.apply(1));      // out:2
System.out.println(function1.compose(function).apply(1));   // out:4
System.out.println(function1.andThen(function).apply(1));   // out:3

BiFunction<Integer, Integer, Long> bF = (i1, i2) -> Long.parseLong(i1+i2+"");
System.out.println(bF.apply(1, 2));      // out:3

DIYBiFunction<Integer, Integer, Integer, Integer> diyBiFunction = (n1,n2,n3) -> n1+n2+n3;
System.out.println(diyBiFunction.apply(1,2,3)); //out:6

public interface DIYBiFunction<T, U, E, R> {
  R apply(T t, U u, E e);
}
public class DIYBiFunctionImpl implements DIYBiFunction {
  @Override
  public Object apply(Object o, Object o2, Object o3) {
    if (o instanceof Integer
        && o2 instanceof Integer
        && o3 instanceof Integer) {
      return (Integer)o + (Integer)o2 + (Integer)o3;
    } else {
      return null;
    }
  }
}

Predicate 谓词：

判断输入的对象是否符合某个条件

BiPredicate

public class BiPredicateTest { 
    public static void main(String[] args) { 
        // 表示一个谓词 
        Predicate<String> p1 = p -> p.length() > 2; 
        System.out.println(p1.test("1")); 
        System.out.println(p1.test("123")); 
 
        BiPredicate<Integer, String> biPredicate = (i , s) -> s.length() > i; 
        System.out.println(biPredicate.test(1, "12")); 
    } 
} 

Consumer ：

接收一个参数，并执行一段逻辑

BiConsumer

public class BiConsumerTest { 
    public static void main(String[] args) { 
        Map<Integer, String> map = Maps.newHashMap(); 
        map.put(1, "a"); 
        map.put(2, "b"); 
        map.put(3, "c"); 
        BiConsumer<Integer, String> biConsumer = new BiConsumer<Integer, String>() { 
            @Override 
            public void accept(Integer integer, String s) { 
                System.out.println(String.format("out:%s-%s", integer, s)); 
            } 
        }; 
        map.forEach(biConsumer); 
        map.forEach(new BiC1()); 
        map.forEach(new BiC2()); 
    } 
    private static class BiC1 implements BiConsumer<Integer, String> { 
        @Override 
        public void accept(Integer integer, String s) { 
            System.out.println(String.format("BiC1, out: %s - %s", integer, s)); 
        } 
    } 
    private static class BiC2 implements BiConsumer<Integer, String> { 
        @Override 
        public void accept(Integer integer, String s) { 
            System.out.println(String.format("BiC2, out: %s - %s", integer, s)); 
        } 
    } 
}