com.centit.support.algorithm.GeneralAlgorithm Maven / Gradle / Ivy

Go to download
package com.centit.support.algorithm;

import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.util.TypeUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;

import java.io.Serializable;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.function.Function;

/**
 * Created by codefan on 17-9-7.
 *
 * @author codefan
 */
@SuppressWarnings("unused")
public abstract class GeneralAlgorithm {

    private GeneralAlgorithm() {
        throw new IllegalAccessError("Utility class");
    }

    public static  T nvl(T obj, T obj2) {
        return obj == null ? obj2 : obj;
    }

    public static  T nvl2(Object obj, T obj2, T obj3) {
        return obj == null ? obj3 : obj2;
    }

    public static boolean equals(Object operand, Object operand2) {
        if (operand == operand2) {
            return true;
        }
        if (operand == null || operand2 == null) {
            return false;
        }
        return operand.equals(operand2);
    }

    public static int compareTwoObject(Object operand, Object operand2, boolean nullAsFirst) {
        if (operand == null && operand2 == null) {
            return 0;
        }

        if (operand == null) {
            return nullAsFirst ? -1 : 1;
        }

        if (operand2 == null) {
            return nullAsFirst ? 1 : -1;
        }

        if (NumberBaseOpt.isNumber(operand)
            && NumberBaseOpt.isNumber(operand2)) {
            return ObjectUtils.compare(
                NumberBaseOpt.castObjectToDouble(operand),
                NumberBaseOpt.castObjectToDouble(operand2));
        }

        return ObjectUtils.compare(
            StringBaseOpt.objectToString(operand),
            StringBaseOpt.objectToString(operand2));
    }

    public static int compareTwoObject(Object operand, Object operand2) {
        return compareTwoObject(operand, operand2, true);
    }

    /**
     * int compare(final T c1, final T c2)
     * 等价于 ObjectUtils.compare
     *
     * @param          比较对对象类型
     * @param l1          参数1
     * @param l2          参数2
     * @param nullAsFirst true null 在最前面否则在最后面
     * @return 返回比较值 0 相等 1 大于 -1 小于
     * @see org.apache.commons.lang3.ObjectUtils compare
     */
    public static > int compareTwoComparableObject(T l1, T l2, boolean nullAsFirst) {
        return (l1 == null && l2 == null) ? 0 : (
            l1 == null ? (nullAsFirst ? -1 : 1) : (
                l2 == null ? (nullAsFirst ? 1 : -1) : (
                    l1.compareTo(l2)
                )
            )
        );
    }

    public static > int compareTwoComparableObject(T l1, T l2) {
        return compareTwoComparableObject(l1, l2, true);
    }

    /**
     * @param keyExtractor 获取主键方法
     * @param nullAsFirst  true null 在最前面否则在最后面
     * @param           比较对象类型
     * @param           比较主键类型
     * @return 比较结果
     */
    public static > Comparator comparing(
        Function keyExtractor, boolean nullAsFirst) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator & Serializable)
            (c1, c2) ->
                compareTwoComparableObject(keyExtractor.apply(c1), keyExtractor.apply(c2), nullAsFirst);
    }

    private static int getJavaTypeOrder(Object a) {
        switch (ReflectionOpt.getJavaTypeName(a.getClass())) {
            case "int":
            case "Integer":
                return 1;
            case "long":
            case "Long":
                return 2;
            case "float":
            case "Float":
                return 3;
            case "double":
            case "Double":
                return 4;
            case "BigInteger":
                return 5;
            case "BigDecimal":
                return 6;
            case "String":
                return 10;
            default:
                return 100;
        }
    }

    /**
     * 将两个对象加+起来，可能是数字相加，也可能是字符串连接
     *
     * @param a object1
     * @param b object2
     * @return 相加结果
     */
    public static Object addTwoObject(Object a, Object b) {
        if (a == null) {
            if (b == null || b instanceof java.lang.Number) {
                return null;
            }
            return b;
        }
        if (b == null) {
            if (a instanceof java.lang.Number) {
                return null;
            }
            return a;
        }

        if (a instanceof java.lang.Number && b instanceof java.lang.Number) {
            int retType = Math.max(getJavaTypeOrder(a), getJavaTypeOrder(b));
            switch (retType) {
                case 1:
                    return NumberBaseOpt.castObjectToInteger(a) +
                        NumberBaseOpt.castObjectToInteger(b);
                case 2:
                    return NumberBaseOpt.castObjectToLong(a) +
                        NumberBaseOpt.castObjectToLong(b);
                case 3:
                    return NumberBaseOpt.castObjectToFloat(a) +
                        NumberBaseOpt.castObjectToFloat(b);
                case 5:
                    return NumberBaseOpt.castObjectToBigInteger(a).add(
                        NumberBaseOpt.castObjectToBigInteger(b));
                case 6:
                    return NumberBaseOpt.castObjectToBigDecimal(a).add(
                        NumberBaseOpt.castObjectToBigDecimal(b));
                case 4:
                default:
                    return NumberBaseOpt.castObjectToDouble(a) +
                        NumberBaseOpt.castObjectToDouble(b);
            }
        } else if (a instanceof Date && NumberBaseOpt.isNumber(b)) {
            float num = NumberBaseOpt.castObjectToFloat(b, 0.f);
            return DatetimeOpt.addDays((Date) a, num);
        } else if (a instanceof Collection) {
            List