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

傷城~ 2022-03-29 02:13 159阅读 0赞

# 函数式接口： #

函数式接口（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)); 
            } 
        } 
    }