function lambda表达式辅助接口

java

Consumer：T -> void

accept 实现方法

public void run(Consumer<String> consumer) {
    // param 是 String 类型的
    consumer.accept(param);
}

andThen 重复调用

public void run(Consumer<String> consumer) {
    // 等于执行两次 accept
    consumer.andThen(param1).accept(param2);
}

Predicate：T -> boolean

test 实现方法

public void run(Predicate<String> predicate) {
    // param 是 String 类型的
    boolean bool = predicate.test(param);
}

and 多条件判断

public void run(Predicate<String> predicate) {
    // param1 && param2
    boolean bool = predicate.and(param1).test(param2);
}

or 容错判断

public void run(Predicate<String> predicate) {
    // param1 || param2
    boolean bool = predicate.or(param1).test(param2);
}

negate 取反判断

public void run(Predicate<String> predicate) {
    // !param
    boolean bool = predicate.negate().test(param);
}

isEqual 值相同判断

• 作用和 equals 完全一样
• 但 equals 存在NPE风险，isEqual 底层会做null判断

public void run(String param) {
    // 和 param.equals("lidaye") 作用一样
    boolean bool = Predicate.isEqual(param).test("lidaye");
}

Function：T -> R

apply 实现方法

// 模拟状态码
private static Integer code = 404;
public static void main(String[] args) {
    // 调用：设定不同状态码的含义
    run(c -> {
        String msg = "ojbk";
        switch (c){
            case 403:
                msg = "未授权！";
                break;
            case 404:
                msg = "找不到页面！";
                break;
            case 500:
                msg = "网络异常！";
                break;
            default:
        }
        return msg;
    });
}
// 封装 lambda 方法
public static String run(Function<Integer,String> function) {
    return function.apply(code);
}

compose 先执行逻辑

• 先 compose 再 function
  
  • 先 10*10=100 再 100*2=200

// 模拟一个数值
private static Integer num = 10;
public static void main(String[] ages){
    // 调用传入一个逻辑 function
    run(u -> u * 2);
}
// 封装 lambda 方法
public static Integer run(Function<Integer,Integer> function) {
    // 先执行 compose() 参数中的逻辑（n * n）
    // 再吧 n * n 的结果传给 function 逻辑
    return function.compose((Function<Integer, Integer>) n -> n * n).apply(num);
}

andThen 后执行逻辑

• 先 function 再 andThen
  
  • 先 10*2=20 再 20*20=400

// 模拟一个数值
private static Integer num = 10;
public static void main(String[] ages){
    // 调用传入一个逻辑 function
    run(u -> u * 2);
}
// 封装 lambda 方法
public static Integer run(Function<Integer,Integer> function) {
    // 先执行 function 逻辑（n * 2）
    // 再吧 n * 2 的结果传给 andThen() 参数中的逻辑
    return function.andThen(n -> n * n).apply(num);
}

identity 静态取Function对象

public static void main(String[] ages){
    // 调用传入一个值
    run(10);
}
// 封装 lambda 方法
public static Integer run(Integer num) {
    Integer i = (Integer) Function
            // 取 Function 对象
            .identity()
            // 传入逻辑
            .compose((Function<Integer, Integer>) n -> n * n)
            // 传入参数值
            .apply(num);
    // 返回结果
    return i;
}

Supplier：() -> T

get 实现方法

• 通过实现逻辑返回指定类型的值

public static void main(String[] ages){
    // 传入数据，拿到数组
    run(() -> {
        List<User> users = new ArrayList<>();
        users.add(new User("李大爷", 20));
        users.add(new User("胡大妈", 18));
        return users;
    });
}
// 封装 lambda 方法
public static String[] run(Supplier<List<User>> supplier) {
    List<User> users = supplier.get();
    List<String> list = new ArrayList<>(users.size());
    // 遍历取出 name 的值
    users.forEach(u -> list.add(u.getName()));
    return list.toArray(new String[0]);
}

UnaryOperator：T -> T

• 继承了 Function，所以他是一个特殊的 Function。

// 参数类型和返回类型一样的 Function
UnaryOperator<T> extends Function<T, T>

调用案例

• 方法调用和 Function 一样，只是返回值类型和参数类型一样
• 10*10=100

public static void main(String[] ages){
    // 传入数据
    System.out.println(run(u -> u * u));
}
public static Integer run(UnaryOperator<Integer> unaryOperator) {
        return unaryOperator.apply(10);
}

BiConsumer：(T,U) -> void

public void run(BiConsumer<String, Integer> biConsumer) {
    // 实现方法时可以接收两个参数
    biConsumer.accept(name,age);
}

BiPredicate：(T,U) -> boolean

public void run(BiPredicate<String, Integer> biPredicate) {
    // 实现方法时可以接收两个参数
    boolean bool = biPredicate.test(name,age);
}

BiFunction：(T,U) -> R

public static String run(BiFunction<Integer, String, String> biFunction) {
    return biFunction.apply(code,String);
}

BinaryOperator：(T,T) -> T

minBy 取最小值

public static Integer run(int num1, int num2) {
    return BinaryOperator
            // 设置Comparator排序规则
            .minBy((Comparator<Integer>)(i1,i2) -> i1-i2)
            // 传入排序参数
            .apply(num1,num2);
}

maxBy 取最大值

public static Integer run(int num1, int num2) {
    return BinaryOperator
            // 设置Comparator排序规则
            .maxBy((Comparator<Integer>)(i1,i2) -> i1-i2)
            // 传入排序参数
            .apply(num1,num2);
}