Java1.8 工具类 函数式编程去掉if else

package com.ele.util;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;


public interface IIfUtil {

    IIfUtil build = new IIfUtil() {};

    
    default  R thenIf(Function then, P param, Predicate
 rule) {
        return rule.test(param) ? then.apply(param) : null;
    }

    default  R ifThen(P param, Predicate
 rule, Function then) {
        return rule.test(param) ? then.apply(param) : null;
    }

    default  R ifOrElseFun(T param, Predicate rule, Function then, Function orElse) {
        return rule.test(param) ? then.apply(param) : orElse.apply(param);
    }

    default  R ifOrElseGet(boolean rule, Supplier then, Supplier orElse) {
        return rule ? then.get() : orElse.get();
    }

    default  void ifOrElseVoid(T param, Predicate rule, Consumer then, Consumer orElse) {
        if (rule.test(param)) {
            then.accept(param);
        } else {
            orElse.accept(param);
        }
    }


    default 
 void elseIfVoidByKey(P param, boolean ifRule, Consumer
 ifThen, boolean elseRule, Consumer
 elseThen) {
        if (ifRule) {
            ifThen.accept(param);
        } else if (elseRule) {
            elseThen.accept(param);
        }
    }

    default 
 void elseIfVoidByKey(P param, boolean ifRule, Consumer
 ifThen, boolean elseRule, Consumer
 elseThen, Consumer
 defaultThen) {
        if (ifRule) {
            ifThen.accept(param);
        } else if (elseRule) {
            elseThen.accept(param);
        } else {
            defaultThen.accept(param);
        }
    }

    default  R elseIfFunByKey(P param, boolean ifRule, Function ifThen, boolean elseRule, Function elseThen) {
        return elseIfFunDefaultValByKey(param, ifRule, ifThen, elseRule, elseThen, null);
    }

    default  R elseIfFunDefaultValByKey(P param, boolean ifRule, Function ifThen, boolean elseRule, Function elseThen, R defaultVal) {
        if (ifRule) {
            return ifThen.apply(param);
        } else if (elseRule) {
            return elseThen.apply(param);
        } else {
            return defaultVal;
        }
    }

    default  R elseIfFunDefaultFunByKey(P param, boolean ifRule, Function ifThen, boolean elseRule, Function elseThen, Function defaultThen) {
        if (ifRule) {
            return ifThen.apply(param);
        } else if (elseRule) {
            return elseThen.apply(param);
        } else {
            return defaultThen.apply(param);
        }
    }

    default  R elseIfGetByKey(boolean ifRule, Supplier ifThen, boolean elseRule, Supplier elseThen) {
        return elseIfGetDefaultValByKey(ifRule, ifThen, elseRule, elseThen, null);
    }

    default  R elseIfGetDefaultValByKey(boolean ifRule, Supplier ifThen, boolean elseRule, Supplier elseThen, R defaultVal) {
        if (ifRule) {
            return ifThen.get();
        } else if (elseRule) {
            return elseThen.get();
        } else {
            return defaultVal;
        }
    }

    default  R elseIfGetDefaultGetByKey(boolean ifRule, Supplier ifThen, boolean elseRule, Supplier elseThen, Supplier defaultGet) {
        if (ifRule) {
            return ifThen.get();
        } else if (elseRule) {
            return elseThen.get();
        } else {
            return defaultGet.get();
        }
    }


    default 
 void elseIfVoidByFields(P param, Predicate
 ifRule, Consumer
 ifThen, Predicate
 elseRule, Consumer
 elseThen) {
        if (ifRule.test(param)) {
            ifThen.accept(param);
        } else if (elseRule.test(param)) {
            elseThen.accept(param);
        }
    }

    default 
 void elseIfVoidByFields(P param, Predicate
 ifRule, Consumer
 ifThen, Predicate
 elseRule, Consumer
 elseThen, Consumer
 defaultThen) {
        if (ifRule.test(param)) {
            ifThen.accept(param);
        } else if (elseRule.test(param)) {
            elseThen.accept(param);
        } else {
            defaultThen.accept(param);
        }
    }

    default  R elseIfFunByFields(P param, Predicate
 ifRule, Function ifThen, Predicate
 elseRule, Function elseThen) {
        return elseIfFunDefaultValByFields(param, ifRule, ifThen, elseRule, elseThen, null);
    }

    default  R elseIfFunDefaultValByFields(P param, Predicate
 ifRule, Function ifThen, Predicate
 elseRule, Function elseThen, R defaultVal) {
        if (ifRule.test(param)) {
            return ifThen.apply(param);
        } else if (elseRule.test(param)) {
            return elseThen.apply(param);
        } else {
            return defaultVal;
        }
    }

    default  R elseIfFunDefaultFunByFields(P param, Predicate
 ifRule, Function ifThen, Predicate
 elseRule, Function elseThen, Function defaultThen) {
        if (ifRule.test(param)) {
            return ifThen.apply(param);
        } else if (elseRule.test(param)) {
            return elseThen.apply(param);
        } else {
            return defaultThen.apply(param);
        }
    }

    default  R elseIfGetByTest(Supplier ifRule, Supplier ifThen, Supplier elseRule, Supplier elseThen) {
        return elseIfGetDefaultValByTest(ifRule, ifThen, elseRule, elseThen, null);
    }

    default  R elseIfGetDefaultValByTest(Supplier ifRule, Supplier ifThen, Supplier elseRule, Supplier elseThen, R defaultVal) {
        if (ifRule.get()) {
            return ifThen.get();
        } else if (elseRule.get()) {
            return elseThen.get();
        } else {
            return defaultVal;
        }
    }

    default  R elseIfGetDefaultGetByTest(Supplier ifRule, Supplier ifThen, Supplier elseRule, Supplier elseThen, Supplier defaultGet) {
        if (ifRule.get()) {
            return ifThen.get();
        } else if (elseRule.get()) {
            return elseThen.get();
        } else {
            return defaultGet.get();
        }
    }
}

package com.ele.util;

import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;


public interface IMapIfUtil {

    IMapIfUtil build = new IMapIfUtil() {};

    default  R mapIfFunDefaultNull(K key, Map> ruleMap) {
        return mapIfFunDefaultVal(key, null, ruleMap);
    }

    default  R mapIfFunDefaultVal(K key, R defaultVal, Map> ruleMap) {
        return ruleMap.containsKey(key) ? ruleMap.get(key).apply(key) : defaultVal;
    }

    default  R mapIfFunDefaultFun(K key, Function defaultFun, Map> ruleMap) {
        return ruleMap.containsKey(key) ? ruleMap.get(key).apply(key) : defaultFun.apply(key);
    }

    default  void mapIfVoid(K key, Map> ruleMap) {
        if (ruleMap.containsKey(key)) {
            ruleMap.get(key).accept(key);
        }
    }

    default  void mapIfVoidDefault(K key, Consumer defaultFun, Map> ruleMap) {
        if (ruleMap.containsKey(key)) {
            ruleMap.get(key).accept(key);
        } else {
            defaultFun.accept(key);
        }
    }

    default  R mapIfGetDefaultNull(K key, Map> ruleMap) {
        return mapIfGetDefaultVal(key, null, ruleMap);
    }

    default  R mapIfGetDefaultVal(K key, R defaultVal, Map> ruleMap) {
        return ruleMap.containsKey(key) ? ruleMap.get(key).get() : defaultVal;
    }

    default  R mapIfGetDefaultGet(K key, Supplier defaultGet, Map> ruleMap) {
        return ruleMap.containsKey(key) ? ruleMap.get(key).get() : defaultGet.get();
    }

    default  R mapIfFunDefaultNullByKey(P param, K key, Map> ruleMap) {
        return mapIfFunDefaultValByKey(param, key, null, ruleMap);
    }

    default  R mapIfFunDefaultValByKey(P param, K key, R defaultVal, Map> ruleMap) {
        return ruleMap.containsKey(key) ? ruleMap.get(key).apply(param) : defaultVal;
    }

    default  R mapIfFunDefaultFunByKey(P param, K key, Function defaultFun, Map> ruleMap) {
        return ruleMap.containsKey(key) ? ruleMap.get(key).apply(param) : defaultFun.apply(param);
    }

    default  void mapIfVoidByKey(P param, K key, Map> ruleMap) {
        if (ruleMap.containsKey(key)) {
            ruleMap.get(key).accept(param);
        }
    }

    default  void mapIfVoidDefaultByKey(P param, K key, Consumer
 defaultFun, Map> ruleMap) {
        if (ruleMap.containsKey(key)) {
            ruleMap.get(key).accept(param);
        } else {
            defaultFun.accept(param);
        }
    }

    default  R mapIfFunDefaultNullByField(P param, Function fieldKey, Map> ruleMap) {
        return mapIfFunDefaultValByField(param, fieldKey, null, ruleMap);
    }

    default  R mapIfFunDefaultValByField(P param, Function fieldKey, R defaultVal, Map> ruleMap) {
        K k = fieldKey.apply(param);
        return ruleMap.containsKey(k) ? ruleMap.get(k).apply(param) : defaultVal;
    }

    default  R mapIfFunDefaultFunByField(P param, Function fieldKey, Function defaultFun, Map> ruleMap) {
        K k = fieldKey.apply(param);
        return ruleMap.containsKey(k) ? ruleMap.get(k).apply(param) : defaultFun.apply(param);
    }

    default  void mapIfVoidByField(P param, Function fieldKey, Map> ruleMap) {
        K k = fieldKey.apply(param);
        if (ruleMap.containsKey(k)) {
            ruleMap.get(k).accept(param);
        }
    }

    default  void mapIfVoidDefaultByField(P param, Function fieldKey, Consumer
 defaultFun, Map> ruleMap) {
        K k = fieldKey.apply(param);
        if (ruleMap.containsKey(k)) {
            ruleMap.get(k).accept(param);
        } else {
            defaultFun.accept(param);
        }
    }
}

package com.ele.util;

import javafx.util.Pair;

import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;


public interface IPairIfUtil {

    IPairIfUtil build = new IPairIfUtil() {};

    ///
    default 
 void pairsIfVoidByKey(P param, Pair>... then) {
        pairsIfVoidByKey(param, null, then);
    }

    default 
 void pairsIfVoidByKey(P param, Consumer
 defaultThen, Pair> ... then) {
        for (Pair> pair : then) {
            if (pair.getKey()) {
                pair.getValue().accept(param);
                return;
            }
        }
        defaultThen.accept(param);
    }

    default  R pairsIfFunByKey(P param, Pair> ... then) {
        return pairsIfFunDefaultValByKey(param, null, then);
    }

    default  R pairsIfFunDefaultValByKey(P param, R defaultVal, Pair> ... then) {
        for (Pair> pair : then) {
            if (pair.getKey()) {
                return pair.getValue().apply(param);
            }
        }
        return defaultVal;
    }

    default  R pairsIfFunDefaultFunByKey(P param, Function defaultThen, Pair> ... then) {
        for (Pair> pair : then) {
            if (pair.getKey()) {
                return pair.getValue().apply(param);
            }
        }
        return defaultThen.apply(param);
    }


    default 
 void pairsIfVoidByFields(P param, Pair, Consumer
> ... then) {
        pairsIfVoidByFields(param, null, then);
    }

    default 
 void pairsIfVoidByFields(P param, Consumer
 defaultThen, Pair, Consumer
> ... then) {
        for (Pair, Consumer
> pair : then) {
            if (pair.getKey().test(param)) {
                pair.getValue().accept(param);
                return;
            }
        }
        defaultThen.accept(param);
    }

    default  R pairsIfFunByFields(P param, Pair, Function> ... then) {
        return pairsIfFunDefaultValByFields(param, null, then);
    }

    default  R pairsIfFunDefaultValByFields(P param, R defaultVal, Pair, Function> ... then) {
        for (Pair, Function> pair : then) {
            if (pair.getKey().test(param)) {
                return pair.getValue().apply(param);
            }
        }
        return defaultVal;
    }

    default  R pairsIfFunDefaultFunByFields(P param, Function defaultThen, Pair, Function> ... then) {
        for (Pair, Function> pair : then) {
            if (pair.getKey().test(param)) {
                return pair.getValue().apply(param);
            }
        }
        return defaultThen.apply(param);
    }

    default  R pairsIfGetByTest(Pair, Supplier> ... then) {
        return pairsIfGetDefaultValByTest(null, then);
    }

    default  R pairsIfGetDefaultValByTest(R defaultVal, Pair, Supplier> ... then) {
        for (Pair, Supplier> pair : then) {
            if (pair.getKey().get()) {
                return pair.getValue().get();
            }
        }
        return defaultVal;
    }

    default  R pairsIfGetDefaultGetByTest(Supplier elseThen, Supplier defaultGet, Pair, Supplier> ... then) {
        for (Pair, Supplier> pair : then) {
            if (pair.getKey().get()) {
                return pair.getValue().get();
            }
        }
        return defaultGet.get();
    }

}

package com.ele.util;


public interface IIfUtils extends IIfUtil, IPairIfUtil, IMapIfUtil {

    IIfUtils build = new IIfUtils() {};

}