Function工具类

• JDK版本： >=1.8
• 工具类功能：
  用于减少 if 判断：调用方法前，进行验证（非空验证、自定义验证，类似于if判断），验证通过则调用、验证失败则放弃调用
• 主要功能：写着玩，消磨时间

import java.util.function.BiFunction;
import java.util.function.Function;

/**
 * @Author: syf
 * @Description: 方法工具
 * @Date: 2021-09-03 下午 2:40
 */
public class FunctionUtil {

    /**
     * 不为空，则运行（无参，无返回）
     * @param o 参数一
     * @param function  运行方法
     */
    public static void ifNotNull(Object o, RunFunction function){
        isRun(o != null, function);
    }

    /**
     * 不为空，则运行（一参，无返回）
     * @param t     参数一
     * @param function  运行方法
     */
    public static <T> void ifNotNull(T t, VoidFunction<T> function){
        isRun(t != null, t, function);
    }

    /**
     * 不为空，则运行（两参，无返回）
     * @param t     参数一
     * @param r     参数二
     * @param function  运行方法
     */
    public static <T, R> void ifNotNull(T t, R r, OneFunction<T, R> function) {
        isRun(t != null && r != null, t, r, function);
    }

    /**
     * 不为空，则运行（无参，有返回）
     * @param o         参数一
     * @param function  运行方法
     * @return  o != null ? function.return : null
     */
    public static <T> T ifNotNull(Object o, RunReturnFunction<T> function) {
        return isRun(o != null, function);
    }

    /**
     * 不为空，则运行（一参，有返回）
     * @param t     参数一
     * @param function  运行方法
     * @return  t != null ? function.return : null
     */
    public static <T, R> R ifNotNull(T t, Function<T, R> function) {
        return isRun(t != null, t, function);
    }

    /**
     * 不为空，则运行（两参，有返回）
     * @param t     参数一
     * @param r     参数二
     * @param function  运行方法
     * @return  t != null && r != null ? function.return : null
     */
    public static <T, R, U> U ifNotNull(T t, R r, BiFunction<T, R, U> function) {
        return isRun(t != null && r != null, t, r, function);
    }

    /**
     * 符合条件，则运行（无参，无返回）
     * @param flag  条件
     * @param function  运行方法
     */
    public static void isRun(boolean flag, RunFunction function) {
        if(flag) {
            function.run();
        }
    }

    /**
     * 符合条件，则运行（一参，无返回）
     * @param flag  条件
     * @param t     参数一
     * @param function  运行方法
     */
    public static <T> void isRun(boolean flag, T t, VoidFunction<T> function) {
        if(flag) {
            function.run(t);
        }
    }

    /**
     * 符合条件，则运行（两参，无返回）
     * @param flag  条件
     * @param t     参数一
     * @param r     参数二
     * @param function  运行方法
     */
    public static <T, R> void isRun(boolean flag, T t, R r, OneFunction<T, R> function) {
        if(flag) {
            function.run(t, r);
        }
    }

    /**
     * 符合条件，则运行（无参，有返回）
     * @param flag  条件
     * @param function  运行方法
     * @return  flag ? function.return : null
     */
    public static <T> T isRun(boolean flag, RunReturnFunction<T> function) {
        if(flag){
            return function.run();
        }
        return null;
    }

    /**
     * 符合条件，则运行（一参，有返回）
     * @param flag  条件
     * @param t     参数一
     * @param function  运行方法
     * @return  flag ? function.return : null
     */
    public static <T, R> R isRun(boolean flag, T t, Function<T, R> function) {
        if(flag){
            return function.apply(t);
        }
        return null;
    }

    /**
     * 符合条件，则运行（两参，有返回）
     * @param flag  条件
     * @param t     参数一
     * @param r     参数二
     * @param function  运行方法
     * @return  flag ? function.return : null
     */
    public static <T, R, U> U isRun(boolean flag, T t, R r, BiFunction<T, R, U> function) {
        if(flag){
            return function.apply(t, r);
        }
        return null;
    }


    @FunctionalInterface
    interface RunFunction {
        void run();
    }

    @FunctionalInterface
    interface VoidFunction<T> {
        void run(T t);
    }

    @FunctionalInterface
    interface OneFunction<T, R> {
        void run(T t, R r);
    }

    @FunctionalInterface
    interface RunReturnFunction<T> {
        T run();
    }

    @FunctionalInterface
    interface ObjectFunction {
        void run(Object... o);
    }

}