bladex/blade-service/blade-manager/src/main/java/com/mixsmart/utils/CustomFunction.java

package com.mixsmart.utils;


import cn.hutool.core.date.*;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.NumberUtil;
import com.alibaba.fastjson.JSON;
import com.jfireel.expression.Expression;
import com.jfireel.expression.node.CalculateNode;
import com.jfireel.expression.node.impl.OperatorResultNode;
import com.jfireel.expression.node.impl.StaticObjectMethodNode;
import com.jfireel.expression.node.impl.VariableNode;
import com.jfireel.expression.token.Token;
import org.apache.commons.collections4.MapUtils;
import org.jsoup.Jsoup;
import org.springblade.core.tool.utils.*;
import org.springblade.manager.formula.ElementBlock;
import org.springblade.manager.formula.ItemBlock;
import org.springblade.manager.formula.KeyMapper;

import java.io.FileInputStream;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import static java.math.BigDecimal.ROUND_CEILING;
import static java.math.BigDecimal.ROUND_HALF_UP;


/**
 * @author yangyj
 */
public class CustomFunction {


    /**
     * 类调用地址前缀
     */
    public static final String CLASS_CALL = "T(com.mixsmart.utils.CustomFunction).";
    public static final String CONCAT = "@";
    public static final Set<String> KEYWORD_SET = new HashSet<>();

    static {
        KEYWORD_SET.add("first");
        KEYWORD_SET.add("last");
        KEYWORD_SET.add("empty");
    }


    /**
     * @return java.lang.String
     * @Description 根据桩号类型生成桩号
     * @Param [stationType]
     * @Author yangyj
     * @Date 2021.01.20 17:43
     **/
    public static String createStation(Object stationType) {
        if (StringUtils.isNotEmpty(stationType)) {

            Matcher m = RegexUtils.matcher("[~|-]", handleNull(stationType));
            if (m.find()) {
                StringBuilder sb = new StringBuilder();
                String splitchar = m.group(0);
                String[] arr = stationType.toString().split(splitchar);
                for (String str : arr) {
                    sb.append(singleStation(str)).append(splitchar);
                }
                if (sb.length() > 0) {
                    return sb.deleteCharAt(sb.length() - 1).toString();
                }
            } else {
                return singleStation(stationType);
            }
        }
        return "";
    }


    /**
     * @return java.lang.String[] result[0]：返回桩号前缀;result[1]:实际显示前缀;result[2]:里程数
     * @Description 记录表5输入桩号代码解析，2G1#1+100>>2G1K0+100
     * @Param [stake]
     * @Author yangyj
     * @Date 2021.04.09 11:49
     **/
    public static String[] decodeStake(Object stake) {
        String[] result = new String[]{"", "", ""};
        if (StringUtils.isNotEmpty(stake)) {
            String stakeStr = StringUtils.repaceBlank(stake.toString().toUpperCase());
            Matcher m;
            if (stake.toString().contains("+")) {
                m = RegexUtils.matcher("(([A-Z0-9]*)(#\\d*)?)\\+([\\d||\\.]*)", stakeStr);
                if (m.find()) {
                    String partNoD = m.group(1);
                    String partNoV = m.group(2);
                    String kilometer = m.group(4);
                    result[0] = partNoD;
                    result[1] = partNoV;
                    result[2] = kilometer;
                }
            } else {
                m = RegexUtils.matcher("([A-Z]*)([\\d||\\.]*)", stakeStr);
                if (m.find()) {
                    String partNo = m.group(1);
                    String kilometer = m.group(2);
                    result[0] = partNo;
                    result[1] = partNo;
                    result[2] = kilometer;
                }
            }

        }
        return result;
    }

    public static String[] standardStake(Object stake) {
        String[] result = new String[]{"", ""};
        if (StringUtils.isNotEmpty(stake)) {
            String stakeStr = StringUtils.repaceBlank(stake.toString().toUpperCase());
            Matcher m = RegexUtils.matcher("([A-Z0-9]{0,3})K(\\d{1,3})\\+([\\d||\\.]*)", stakeStr);
            Matcher m2 = RegexUtils.matcher("([A-Z]{0,3})([\\d||\\.]+)", stakeStr);
            if (m.find()) {
                String partNo = m.group(1);
                double km = Double.parseDouble(m.group(2));
                double meter = Double.parseDouble(m.group(3));
                result[0] = partNo;
                int scale = getScale(meter);
                result[1] = StringUtils.number2String(km * 1000 + meter, scale);
            } else if (m2.find()) {
                result[0] = m2.group(1);
                result[1] = m2.group(2);
            }

        }
        return result;
    }

    /**
     * @return int
     * @Description 获取最大小数位
     * @Param [number]
     * @Author yangyj
     * @Date 2021.12.23 15:08
     **/
    public static Integer getScale(Object... number) {
        int max = 0;
        for (Object n : number) {
            if (StringUtils.isNotEmpty(n)) {
                String[] sa = n.toString().split(",");
                for (String s : sa) {
                    Matcher m = RegexUtils.matcher("(\\d)+.(\\d)+", s);
                    if (m.find()) {
                        max = Math.max(new StringBuilder(m.group()).reverse().toString().indexOf("."), max);
                    }
                }
            }
        }
        return max;
    }

    public static String singleStation(Object station) {
        if (StringUtils.isNotEmpty(station)) {
            Object zhdata = station;
            String zhdatastr = zhdata.toString().toUpperCase();
            if (zhdatastr.contains("+") && zhdatastr.contains("K")) {
                return zhdatastr;
            }
            String[] stake = decodeStake(zhdatastr);
            String partNo = stake[1];
            String kilometer = stake[2];
            if (StringUtils.isNotEmpty(kilometer)) {
                partNo = handleNull(partNo);
                int ks = (int) Math.floor(Double.parseDouble(kilometer) / 1000);
                double ke = new BigDecimal(kilometer).subtract(new BigDecimal(String.valueOf(ks * 1000))).doubleValue();
                String temp = "" + ke;
                if ((int) Double.parseDouble(temp) == Double.parseDouble(temp)) {
                    temp = String.valueOf((int) Double.parseDouble(temp));
                }
                String sf = "000";
                if (temp.length() < 3) {
                    temp = sf.substring(0, 3 - temp.length()) + temp;
                }
                if ((temp.contains(".") && temp.indexOf(".") <= 2)) {
                    temp = sf.substring(0, 3 - temp.indexOf(".")) + temp;
                }
                return partNo + "K" + ks + "+" + temp;
            }
        }
        return "";
    }


    public static Object calculate(Object a, Object b, Object scaleObj, Integer type) {
        boolean nullFlag = false;
        if (type == null) {
            return null;
        }
        if (StringUtils.isEmpty(a) && StringUtils.isEmpty(b)) {
            return null;
        }
        if (StringUtils.isEmpty(a) && type == 7) {
            nullFlag = true;
            a = 0;
        }
        if (StringUtils.isEmpty(b) && type == 7) {
            nullFlag = true;
            b = 0;
        }
        if (StringUtils.isNotEmpty(a) && StringUtils.isNotEmpty(b)) {
            try {
                int scale = StringUtils.handleObj2Integer(scaleObj);
                String aStr = a.toString();
                String bStr = b.toString();
                double ad = Double.parseDouble(aStr);
                double bd = 0;
                if (type == 6) {
                    //判断设计值是否包含"/"
                    if (bStr.contains("/")) {
                        bd = bStr.split("/").length;
                        return (int) (ad * bd);
                    } else {
                        return (int) ad;
                    }
                }
                bd = Double.parseDouble(bStr);
                double result = 0;
                if (type == 1) {
                    result = ad + bd;
                } else if (type == 2) {
                    result = ad - bd;
                } else if (type == 3) {
                    result = ad * bd;
                } else if (type == 4) {
                    result = ad / bd;
                } else if (type == 5) {
                    result = ad % bd;
                } else if (type == 7 && ad * bd != 0 && !nullFlag) {
                    return (int) Math.ceil(ad * bd);
                } else {
                    return null;
                }
                BigDecimal big = new BigDecimal(result);
                return big.setScale(scale, ROUND_HALF_UP);
            } catch (NumberFormatException e) {
                e.printStackTrace();
            }
        }
        return null;
    }


    public static boolean isNumber(Object value) {
        if (Func.isEmpty(value)) {
            return false;
        }
        if (value instanceof Number) {
            return true;
        }
        String pattern = "^[+-]?\\d+(\\.\\d+)?$";
        Pattern r = Pattern.compile(pattern);
        Matcher m = r.matcher(String.valueOf(value));
        return m.matches();
    }

    public static boolean isNotNumber(Object value) {
        return !isNumber(value);
    }


    public static Object sum(List<Object> list) {
        if (ListUtils.isNotEmpty(list)) {
            return list.stream().filter(StringUtils::isNumber).map(StringUtils::handleNull).mapToDouble(Double::parseDouble).sum();
        }
        return "";
    }

    public static Object avg(List<Object> list) {
        if (ListUtils.isNotEmpty(list)) {
            OptionalDouble op = list.stream().filter(StringUtils::isNumber).map(StringUtils::handleNull).mapToDouble(Double::parseDouble).average();
            if (op.isPresent()) {
                return op.getAsDouble();
            }
        }
        return "";
    }

    /**
     * @return java.util.List<java.lang.Object>
     * @Description 分段求平均值
     * @Param [data 原数据, n 分段数]
     * @Author yangyj
     * @Date 2023.04.28 10:13
     **/
    public static List<Object> avg4segment(List<Object> data, int n) {
        if (data.isEmpty()) {
            return null;
        }
        if (n <= 1) {
            return Collections.singletonList(avg(data));
        }
        Map<Integer, List<Object>> group = IntStream.range(0, data.size())
                .boxed()
                .collect(Collectors.groupingBy(i -> i / n, LinkedHashMap::new, Collectors.mapping(data::get, Collectors.toList())));
        return group.values().stream().map(CustomFunction::avg).collect(Collectors.toList());
    }


    public static Object max(List<Object> list) {
        if (ListUtils.isNotEmpty(list)) {
            OptionalDouble op = list.stream().filter(StringUtils::isNumber).map(StringUtils::handleNull).mapToDouble(Double::parseDouble).max();
            if (op.isPresent()) {
                return op.getAsDouble();
            }
        }
        return "";
    }

    public static Object min(List<Object> list) {
        if (ListUtils.isNotEmpty(list)) {
            OptionalDouble op = list.stream().filter(StringUtils::isNumber).map(StringUtils::handleNull).mapToDouble(Double::parseDouble).min();
            if (op.isPresent()) {
                return op.getAsDouble();
            }
        }
        return "";
    }

    public static Object count(Object data) {
        List<Object> list = obj2ListNe(data);
        if (ListUtils.isNotEmpty(list)) {
            if (list.stream().anyMatch(e -> !StringUtils.isNumber(e))) {
                return list.stream().filter(StringUtils::isNotEmpty).count();
            }
            return list.stream().filter(StringUtils::isNumber).map(StringUtils::handleNull).mapToDouble(Double::parseDouble).count();
        }
        return "";
    }


    /**
     * @return java.lang.Object
     * @Description 输出勾选复选框
     * @Param [o1, o2]
     * @Author yangyj
     * @Date 2021.06.29 10:35
     **/
    public static Object checkbox(Object o1, Object o2) {
        if (StringUtils.isNotEmpty(o1) && StringUtils.isNotEmpty(o2)) {
            if (o1.equals(o2)) {
                return "\u2611";
            }
        }
        return "";
    }

    /**
     * @return java.lang.Object
     * @Description 返回n个空格，用于输出字符串格式化
     * @Param [n]
     * @Author yangyj
     * @Date 2021.06.29 11:41
     **/
    public static Object space(Object n) {
        if (StringUtils.isNumber(n)) {
            return String.join("", Collections.nCopies(Integer.parseInt(n.toString()), "\u0020"));
        }
        return "";
    }


    /**
     * @return boolean
     * @Description 字符串中是包含中文
     * @Param [chars]
     * @Author yangyj
     * @Date 2021.09.17 14:31
     **/
    public static boolean containsZH(Object chars) {
        Matcher m = RegexUtils.matcher("[\u4e00-\u9fa5]", handleNull(chars));
        return m.find();
    }

    /**
     * @return boolean
     * @Description 字符串中是包含数字
     * @Param [chars]
     * @Author yangyj
     * @Date 2021.09.17 14:31
     **/
    public static boolean containsD(Object chars) {
        Matcher m = RegexUtils.matcher("\\d", handleNull(chars));
        return m.find();
    }


    /**
     * @return java.lang.String
     * @Description 封装超链接
     * @Param [uri]
     * @Author yangyj
     * @Date 2021.10.14 16:15
     **/
    public static String uri(Object uri) {
        if (StringUtils.isNotEmpty(uri)) {
            return "URI<" + handleNull(uri) + ">";
        }
        return "";
    }


    /**
     * @return java.lang.Object
     * @Description 获取相隔多少天后的日期
     * @Param [date, n：相隔天数，正数代表未来，负数代表历史]
     * @Author yangyj
     * @Date 2021.10.27 10:21
     **/
    public static Object dateAfter(Object date, Object n) {
        if (StringUtils.isNotEmpty(date) && StringUtils.isNumber(n)) {
            if (date instanceof List) {
                date = ((List) date).get(0);
            }
            DateTime dt = new DateTime(date.toString());
            dt.offset(DateField.HOUR_OF_DAY, 24 * Integer.parseInt(n.toString()));
            //return dt.toString(DatePattern.UTC_PATTERN);
            return dt.toString(DatePattern.CHINESE_DATE_PATTERN);
        }
        return "";
    }

    public static Object weather(List<Object> date,Map<String,Object> map){
           if(ListUtils.isNotEmpty(date)&&map!=null){
            return  date.stream().map(StringUtils::handleNull).filter(StringUtils::isNotEmpty).map(e->map.get(new DateTime(e).toString(DatePattern.NORM_DATE_PATTERN))).collect(Collectors.toList());
           }
           return "";
    }

    public static Object dateMax(Object range) {
        if (StringUtils.isNotEmpty(range)) {
            String[] s = Func.toStr(range).replaceAll("[\\[\\]]", "").split(",\\s+");
            return dateCp(s[0], s[1], false);
        }
        return StringPool.EMPTY;
    }

    public static Object dateMin(Object range) {
        if (StringUtils.isNotEmpty(range)) {
            String[] s = Func.toStr(range).replaceAll("[|]", "").split(",");
            return dateCp(s[0], s[1], true);
        }
        return StringPool.EMPTY;
    }

    private static Object dateCp(Object d1, Object d2, Boolean isAsc) {
        if (d1 != null && d2 != null) {
            Map<DateTime, Object> map = new HashMap<>();
            DateTime dt1 = new DateTime(d1.toString());
            DateTime dt2 = new DateTime(d2.toString());
            map.put(dt1, d1);
            map.put(dt2, d2);
            List<DateTime> list = new ArrayList<>();
            list.add(dt1);
            list.add(dt2);
            if (isAsc) {
                return map.get(dcp(list, Comparator.naturalOrder()));
            } else {
                return map.get(dcp(list, Comparator.reverseOrder()));
            }
        }
        return StringPool.EMPTY;
    }


    /**
     * @return java.lang.Object
     * @Description 优良占比
     * @Param [data, cp]
     * @Author yangyj
     * @Date 2022.12.21 12:00
     **/
    public static Object proportion(List<Object> data, String cp) {
        if (Func.isNotEmpty(data) && Func.isNotBlank(cp)) {
            data = data.stream().filter(Func::isNotEmpty).map(e -> e.toString().replaceAll("\\s+", "")).collect(Collectors.toList());
            return StringUtils.number2String(100 * ((double) data.stream().filter(e -> StringUtils.isEquals(e, cp)).count()) / (double) data.size(), 1);
        }
        return "";
    }


    public static Object goodSize(List<Object> data, String cp) {
        if (Func.isNotEmpty(data) && Func.isNotBlank(cp)) {
            data = data.stream().filter(Func::isNotEmpty).map(e -> e.toString().replaceAll("\\s+", "")).collect(Collectors.toList());
            return data.stream().filter(e -> StringUtils.isEquals(e, cp)).count();
        }
        return "";
    }

    /**
     * @return java.lang.Object
     * @Description 阶梯合格率
     * @Param [data]
     * @Author yangyj
     * @Date 2022.12.21 11:59
     **/
    public static Object ladder(List<Object> data) {
        if (Func.isNotEmpty(data)) {
            OptionalDouble op = data.stream().map(StringUtils::handleNull).filter(StringUtils::isNumber).mapToDouble(Double::parseDouble).min();
            if (op.isPresent()) {
                return op.getAsDouble() >= 90 ? 90 : 70;
            }
        }
        return "";
    }

    /**
     * @return java.lang.Object
     * @Description 主要工序质量等级
     * @Param [data]
     * @Author yangyj
     * @Date 2022.12.21 14:18
     **/
    public static Object major(List<Object> data) {
        if (Func.isNotEmpty(data) && data.stream().anyMatch(StringUtils::isNotEmpty)) {
            return data.stream().map(StringUtils::handleNull).distinct().collect(Collectors.toList()).stream().anyMatch(e -> e.contains("合格")) ? "合格" : "优良";
        }
        return "";
    }

    /**
     * @return java.lang.Object
     * @Description 单元工程质量等级评定
     * @Param [rate, level]
     * @Author yangyj
     * @Date 2022.12.21 14:33
     **/
    public static Object unit(Object rate, Object level) {

        if (StringUtils.isNotEmpty(rate, level)) {
            return StringUtils.obj2Double(rate.toString()) > 50 && "优良".equals(level.toString()) ? "优良" : "合格";
        }
        return "";
    }

    /**
     * @return java.lang.Object
     * @Description 主控项目数量
     * @Param [data]
     * @Author yangyj
     * @Date 2022.12.21 15:37
     **/
    public static Object reasonable(List<Object> data) {

        if (ListUtils.isNotEmpty(data)) {
            return data.stream().map(e -> StringUtils.handleNull(e).replace("/", "")).filter(StringUtils::isNotEmpty).count();
        }
        return "";
    }


    /**
     * @return cn.hutool.core.date.DateTime
     * @Description 时间比较获取
     * @Param [list：时间集合, comparator 比较器 ]
     * @Author yangyj
     * @Date 2022.11.10 10:47
     **/
    public static DateTime dcp(List<DateTime> list, Comparator<? super DateTime> comparator) {
        return list.stream().reduce((a, b) -> comparator.compare(a, b) <= 0 ? a : b).orElse(null);
    }


    public static String dateToStr(Date date, String formatter) {
        String value = null;
        if (null != date) {
            if (StringUtils.isEmpty(formatter)) {
                formatter = "yyyy-MM-dd HH:mm:ss";
            }
            SimpleDateFormat dateFormat = new SimpleDateFormat(formatter);
            value = dateFormat.format(date);
            dateFormat = null;
        }
        return value;
    }


    public static String summary(List<String> tableNames) {
        if (ListUtils.isNotEmpty(tableNames)) {
            return tableNames.stream().map(e -> e.replaceAll("_(PL)?_\\d+$", "")).distinct().collect(Collectors.joining(StringPool.NEWLINE));
        }
        return StringPool.EMPTY;
    }

    ;


    public String checkItems(List<String> items, List<Object> l1, List<Object> l2, List<Object> l3, List<Object> l4, List<Object> l5, List<Object> l6, List<Object> l7, List<Object> l8, List<Object> l9, List<Object> l10, List<Object> l11, List<Object> l12) {
        List<List<Object>> data = new ArrayList<>(Arrays.asList(l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12));
        List<String> result = new ArrayList<>();
        for (int i = 0; i < data.size(); i++) {
            List<Object> list = data.get(i);
            if (list.stream().anyMatch(StringUtils::isNotEmpty)) {
                result.add(items.get(i));
            }
        }
        if (ListUtils.isNotEmpty(result)) {
            return String.join("、", result);
        }
        return StringPool.EMPTY;
    }


    /**
     * @return java.lang.Object
     * @Description 计算t1~t2,t3~t4 两个时间段的合计时间，unit 输入数值的单位
     * @Param [t1, t2, t3, t4, unit]
     * @Author yangyj
     * @Date 2021.07.02 15:47
     **/
    public static Object totalTime(Object t1, Object t2, Object t3, Object t4, Object unit) {
        if (StringUtils.isNotEmpty(t1) && StringUtils.isNotEmpty(t2) && StringUtils.isNotEmpty(t3) && StringUtils.isNotEmpty(t4) && StringUtils.isNotEmpty(unit)) {
            return conversionUnit((Long.parseLong(minutesPassedRecent(t1, t2).toString()) + Long.parseLong(minutesPassedRecent(t3, t4).toString())), unit);
        }
        return "";
    }

    /**
     * @return java.lang.Object
     * @Description 字符串日期转指定格式日期
     * @Param [date, format：输出格式]
     * @Author yangyj
     * @Date 2021.07.02 15:55
     **/
    public static Object dateFormatter(Object date, Object format) {
        if (StringUtils.isNotEmpty(date) && StringUtils.isNotEmpty(format)) {
            Matcher m = RegexUtils.matcher("(\\d{4})\\D(\\d{2})\\D(\\d{2})日?\\s*(\\d{0,2})(\\D\\d{1,2})?", date.toString());
            if (m.find()) {
                String yyyy = handleNull(m.group(1));
                String MM = handleNull(m.group(2));
                String dd = handleNull(m.group(3));
                String HH = handleNull(m.group(4));
                String mm = handleNull(m.group(5));
                String d = handleNull(format);
                if (StringUtils.isNotEmpty(yyyy)) {
                    d = d.replace("yyyy", yyyy);
                }
                if (StringUtils.isNotEmpty(MM)) {
                    d = d.replace("MM", MM);
                }
                if (StringUtils.isNotEmpty(dd)) {
                    d = d.replace("dd", dd);
                }
                if (StringUtils.isNotEmpty(HH)) {
                    d = d.replace("HH", HH);
                }
                if (StringUtils.isNotEmpty(mm)) {
                    mm = mm.replaceAll("\\D", "");
                    d = d.replace("mm", mm);
                }
                return d;
            }
        }
        return "";
    }


    /**
     * @return java.lang.Object
     * @Description 求偏差值
     * @Param [list, design]
     * @Author yangyj
     * @Date 2021.09.18 10:43
     **/
    public static Object deviation(Object list, Object design) {
        if (StringUtils.isNotEmpty(list) && StringUtils.isNumber(design)) {
            List<Object> result = new ArrayList<>();
            List<Object> tmp;
            if (list instanceof List) {
                tmp = (List<Object>) list;
            } else {
                tmp = Arrays.asList(list.toString().split("[,|\\-~，]"));
            }
            int dev = StringUtils.handObj2Integer(design);
            for (Object e : tmp) {
                if (containsZH(e)) {
                    /*不允许包含中文*/
                    return "";
                }
                result.add(StringUtils.handObj2Integer(e) - dev);
            }
            if (ListUtils.isNotEmpty(result)) {
                return result;
            }
        }
        return "";
    }


    /**
     * @return java.lang.Object
     * @Description 把日期格式化成 'xxxx年xx月xx日 星期x' 字符串
     * @Param [date]
     * @Author yangyj
     * @Date 2021.06.21 14:27
     **/
    public static Object toDateAndWeek(Object date) {
        if (StringUtils.isNotEmpty(date)) {
            Date d = parseDate(handleNull(date));
            String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
            Calendar calendar = Calendar.getInstance();
            assert d != null;
            calendar.setTime(d);
            String week = weekDays[calendar.get(Calendar.DAY_OF_WEEK) - 1];
            return dateToStr(d, "yyyy年MM月dd日") + " " + week;
        }
        return null;
    }


    /**
     * @return java.lang.Object
     * @Description
     * @Param [data , unit 输入单位]
     * @Author yangyj
     * @Date 2022.10.13 14:13
     **/
    public static Object conversionUnit(Object data, Object unit) {

        if (StringUtils.isNumber(data) && StringUtils.isNotEmpty(unit)) {
            //统一转化成毫秒在处理
            long ms = 0;
            long l = Long.parseLong(data.toString());
            final long s = 1000L;
            final long m = s * 60;
            final long H = m * 60;
            final long D = H * 24;
            final long M = D * 30;
            final long Y = D * 365;
            if (StringUtils.isEquals("Y", unit.toString())) {
                ms = l * Y;
            } else if (StringUtils.isEquals("M", unit.toString())) {
                ms = l * M;
            } else if (StringUtils.isEquals("D", unit.toString())) {
                ms = l * D;
            } else if (StringUtils.isEquals("H", unit.toString())) {
                ms = l * H;
            } else if (StringUtils.isEquals("m", unit.toString())) {
                ms = l * m;
            }
            StringBuilder sb = new StringBuilder();
            if (ms / Y != 0) {
                sb.append(ms / Y).append("年");
                ms = ms % Y;
            }
            if (ms / M != 0) {
                sb.append(ms / M).append("月");
                ms = ms % M;
            }
            if (ms / D != 0) {
                sb.append(ms / D).append("日");
                ms = ms % D;
            }
            if (ms / H != 0) {
                sb.append(ms / H).append("时");
                ms = ms % H;
            }
            if (ms / m != 0) {
                sb.append(ms / m).append("分");
                ms = ms % m;
            }
            if (sb.length() > 0) {
                return sb.toString();
            }
        }
        return "";
    }

    public static Object fileSize(Object data) {
        return fileSize(data, null);
    }

    public static Object fileSize(Object data, Object unit) {
        if (StringUtils.isNumber(data)) {
            if (StringUtils.isEmpty(unit)) {
                unit = "K";
            }
            //统一转化成KB在处理
            long ms = 0;
            long l = Long.parseLong(data.toString());
            final long KB = 1L;
            final long MB = 1024 * KB;
            final long GB = 1024 * MB;
            final long TB = 1024 * GB;
            if (StringUtils.isEquals("K", unit.toString().toUpperCase())) {
                ms = l * KB;
            } else if (StringUtils.isEquals("M", unit.toString().toUpperCase())) {
                ms = l * MB;
            } else if (StringUtils.isEquals("G", unit.toString().toUpperCase())) {
                ms = l * GB;
            } else if (StringUtils.isEquals("T", unit.toString().toUpperCase())) {
                ms = l * TB;
            }
            if (ms / TB != 0) {
                return new BigDecimal(ms).divide(new BigDecimal(TB), 2, ROUND_HALF_UP) + "TB";
            }
            if (ms / GB != 0) {
                return new BigDecimal(ms).divide(new BigDecimal(GB), 1, ROUND_HALF_UP) + "GB";
            }
            if (ms / MB != 0) {
                return new BigDecimal(ms).divide(new BigDecimal(MB), 0, ROUND_HALF_UP) + "MB";
            }
            return ms + "KB";
        }
        return "";
    }

    public static Object daysPassed(Object t1, Object t2) {
        return timePassed(t1, t2, "D", 0, "yyyy-MM-dd");
    }

    public static Object hoursPassed(Object t1, Object t2) {
        return timePassed(t1, t2, "H", 0, "yyyy-MM-dd HH");
    }

    public static Object minutesPassed(Object t1, Object t2) {
        return timePassed(t1, t2, "m", 0, "yyyy-MM-dd HH:mm");
    }

    /**
     * @return java.lang.Object
     * @Description 输入时间格式：mm:ss(例如01:33)
     * @Param [t1, t2]
     * @Author yangyj
     * @Date 2021.07.02 17:45
     **/
    public static Object minutesPassedRecent(Object t1, Object t2) {
        String year = Calendar.getInstance().get(Calendar.YEAR) + ".";
        int month = Calendar.getInstance().get(Calendar.MONTH) + 1;
        String mstr = "";
        if (month < 10) {
            mstr = "0" + month + ".";
        } else {
            mstr = month + ".";
        }
        int day = Calendar.getInstance().get(Calendar.DATE) + 1;
        String dstr = "";
        if (day < 10) {
            dstr = "0" + day + " ";
        } else {
            dstr = day + " ";
        }
        t1 = year + mstr + dstr + t1;
        t2 = year + mstr + dstr + t2;
        return timePassed(t1, t2, "m", 0, "yyyy-MM-dd HH:mm");
    }


    public static Object hoursPassedRecent(Object t1, Object t2) {
        String year = Calendar.getInstance().get(Calendar.YEAR) + "年";
        t1 = year + t1;
        t1 = t1.toString().replace("日", " ").replace("时", " ");
        t2 = year + t2;
        t2 = t2.toString().replace("日", " ").replace("时", " ");
        return timePassed(t1, t2, "H", 0, "yyyy-MM-dd HH");
    }

    public static Date parseDate(String dateStr) {
        if (StringUtils.isEmpty(dateStr)) {
            return null;
        }
        if (!dateStr.contains("-")) {
            dateStr = StringUtils.repaceBlank(dateStr);
            Matcher m = RegexUtils.matcher("\\d{4}(.)\\d{2}(.)\\d{2}(.?)", dateStr);
            if (m.find()) {
                Set<String> set = new HashSet<>();
                set.add(m.group(1));
                set.add(m.group(2));
                if (StringUtils.isNotEmpty(m.group(3))) {
                    set.add(m.group(3));
                }
                if (!set.isEmpty()) {
                    for (String str : set) {
                        dateStr = dateStr.replace(str, "-");
                    }
                }
            }
        }
        Date datetime = null;
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            datetime = dateFormat.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return datetime;
    }

    public static Date parseDate(Object date, String format) {
        if (date instanceof Date) {
            return (Date) date;
        }
        if (date == null || StringUtils.isEmpty(format)) {
            return null;
        }
        String dateStr = date.toString();
        if (!dateStr.toString().contains("-")) {
            Matcher m = RegexUtils.matcher("\\d{4}(.)\\d{2}(.)\\d{2}(日?)", dateStr);
            if (m.find()) {
                Set<String> set = new HashSet<>();
                set.add(m.group(1));
                set.add(m.group(2));
                if (StringUtils.isNotEmpty(m.group(3))) {
                    dateStr = dateStr.replace(m.group(3), "");
                }
                if (!set.isEmpty()) {
                    for (String str : set) {
                        dateStr = dateStr.replace(str, "-");
                    }
                }
            }
        }
        Date datetime = null;
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        try {
            datetime = dateFormat.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return datetime;
    }

    public static String handleNull(Object obj) {
        if (null == obj) {
            return "";
        } else {
            return obj.toString().trim();
        }
    }

    /**
     * @return java.lang.Object
     * @Description 返回时间间隔差
     * @Param [t1：开始时间, t2：结束时间, mode：返回值单位：Y年 M月 D日 H时 m分,scale：保留小数位, format：输入日期格式]
     * @Author yangyj
     * @Date 2021.07.01 09:57
     **/
    public static Object timePassed(Object t1, Object t2, Object mode, Object scale, Object format) {
        if (t1 != null && t2 != null && StringUtils.isNotEmpty(mode) && StringUtils.isNotEmpty(scale) && StringUtils.isNotEmpty(format)) {
//			Date d1 = parseDate(t1,handleNull(format));
//			Date d2 = parseDate(t2,handleNull(format));
            DateTime d1 = new DateTime(t1.toString());
            DateTime d2 = new DateTime(t2.toString());
//			if(d1.after(d2)&&StringUtils.isEquals("H",mode)){
//				/*假如是计算相差单位是小时，当开始时间大于结束时间，需要考虑跨年的情况*/
//                   Calendar c =Calendar.getInstance();
//                   c.setTime(d1);
//				   c.add(Calendar.YEAR, -1);
//				   d1=new DateTime(c.getTime());
//			}
            long range = d2.getTime() - d1.getTime();
            long r = 0;
            if (StringUtils.isEquals("Y", mode.toString())) {
                r = range / (1000L * 3600 * 24 * 365);
            } else if (StringUtils.isEquals("M", mode.toString())) {
                r = range / (1000L * 3600 * 24 * 30);
            } else if (StringUtils.isEquals("D", mode.toString())) {
                r = range / (1000L * 3600 * 24);
            } else if (StringUtils.isEquals("H", mode.toString())) {
                r = range / (1000L * 3600);
            } else if (StringUtils.isEquals("m", mode.toString())) {
                r = range / (1000L * 60);
            }
            BigDecimal b = new BigDecimal(r);
            if (!StringUtils.isNumber(scale)) {
                scale = 0;
            }
            return b.setScale(Integer.parseInt(scale.toString()), ROUND_HALF_UP);
        }
        return "";
    }


    public static Object k2d(Object k) {
        Matcher mt = RegexUtils.matcher("[A-Z]*(\\d*)\\+([\\d|\\.]*)", k.toString());
        if (mt.find()) {
            return Double.parseDouble(mt.group(1)) * 1000 + Double.parseDouble(mt.group(2));
        }
        return -1;
    }

    /**
     * @return java.lang.Object
     * @Description 开方
     * @Param [a：被开方数, scale：结果的小数位]
     * @Author yangyj
     * @Date 2020.12.10 15:10
     **/
    public static Object sqrt(Object a) {
        if (StringUtils.isNumber(a)) {
            return Math.sqrt(Double.parseDouble(a.toString()));
        }
        return "";
    }


    /**
     * @return java.lang.Object
     * @Description 平方
     * @Param [a：开方数, scale：结果的小数位]
     * @Author yangyj
     * @Date 2020.12.10 15:10
     **/
    public static Object pow(Object a, Object b) {
        if (StringUtils.isNumber(a) && StringUtils.isNumber(b)) {
            return Math.pow(Double.parseDouble(a.toString()), Double.parseDouble(b.toString()));
        }
        return "";
    }

    public static Object pow(Object a) {
        if (StringUtils.isNumber(a)) {
            return Math.pow(Double.parseDouble(a.toString()), 2);
        }
        return "";
    }


    /**
     * @return java.lang.Object
     * @Description 立方
     * @Param [base]
     * @Author yangyj
     * @Date 2022.06.24 16:48
     **/
    public static Object cube(Object base) {
        return pow(base, 3);
    }


    /**
     * @return java.util.List<java.lang.Object>
     * @Description 生成用户指定范围实测值
     * @Param [n 数量, design 设计值, scope 偏差范围, rate 合格率0~1, scale保留小数位]
     * @Author yangyj
     * @Date 2021.08.27 14:47
     **/
    public static List<Object> cmv(Object n, Object design, Object scope, Object rate, Object scale) {
        if (StringUtils.isNotEmpty(n) && StringUtils.isNotEmpty(design) && StringUtils.isNotEmpty(scope) && StringUtils.isNotEmpty(rate) && StringUtils.isNotEmpty(scale)) {
            return rangeList(n, design, scope, 1, scale, rate);
        }
        return null;
    }


    /**
     * @return java.lang.Object
     * @Description 累加器
     * @Param [scale：保留小数位, args：累加对象,支持动态数量]
     * @Author yangyj
     * @Date 2021.05.18 10:40
     **/
    public static Object _sumObj(Object scale, Object... args) {
        double result = 0d;
        boolean flag = false;
        for (Object obj : args) {
            if (StringUtils.isNotEmpty(obj) && StringUtils.isNumber(obj)) {
                result += Double.parseDouble(obj.toString());
                flag = true;
            }
        }
        if (flag) {
            BigDecimal r = new BigDecimal(result);
            return r.setScale((int) Double.parseDouble(scale.toString()), ROUND_HALF_UP);
        }
        return "";
    }


    /**
     * @return java.lang.Object
     * @Description 空白或者/都判断为空
     * @Param [data]
     * @Author yangyj
     * @Date 2022.04.01 15:04
     **/
    public static Object isNotEmpty(Object data) {
        List<Object> list = obj2List(data);
        return list.stream().map(StringUtils::handleNull).anyMatch(e -> !e.contains("/"));
    }

    public static Object isPass(Object data) {
        List<Object> list = obj2List(data);
        return list.stream().map(StringUtils::handleNull).map(e -> !e.contains("/") && StringUtils.isNotEmpty(e) ? "合格" : "").collect(Collectors.toList());
    }


    public static List<Object> b445check(List<Object> data, Object designs, Object dev, Object xN) {
        return b445check(data, designs, dev, xN, null);
    }

    /**
     * @return [共检数量, 合格数量, 不合格数量...]
     * @Description 河南项目检查结果
     * @Param [data, designs, dev, xN, hz]
     * @Author yangyj
     * @Date 2022.08.01 11:06
     **/
    public static List<Object> b445check(List<Object> data, Object designs, Object dev, Object xN, Object hz) {

        List<Object> result = new ArrayList<>();
        designs = designFormat(designs);
        if (StringUtils.isNotEmpty(data, designs, dev)) {
            if (StringUtils.isEmpty(xN)) {
                /*偏差范围单位转换倍率默认是1*/
                /*同一个项目偏差范围单位理应一样，所以不用考虑多个值的情况*/
                xN = 1;
            }
            if (StringUtils.handleNull(designs).contains("/")) {
                /*多个设计值*/
                String[] designArr = designs.toString().split("/");
                String[] devArr = dev.toString().split("/");
                int total = 0;
                int pass = 0;
                List<List<Object>> dl = dataSpaceSplit(data, designArr);
                for (int i = 0; i < designArr.length; i++) {
                    Object[] obs = ck(dl.size() > i ? dl.get(i) : dl.get(dl.size() - 1), designArr[i], devArr.length > i ? devArr[i] : devArr[devArr.length - 1], xN);
                    total += StringUtils.handleObj2Integer(obs[0]);
                    pass += StringUtils.handleObj2Integer(obs[1]);
                }
                if (total > 0) {
                    result.add(total);
                    result.add(pass);
                    result.add(total - pass);
                }
            } else {
                Object[] target = ck(data, designs, dev, xN);
                if (StringUtils.handObj2Integer(target[0]) > 0) {
                    result.add(target[0]);
                    result.add(target[1]);
                    result.add(StringUtils.handObj2Integer(target[0]) - StringUtils.handObj2Integer(target[1]));
                }
            }
        } else if (ListUtils.isNotEmpty(data)) {
            if (data.parallelStream().anyMatch(StringUtils::isNotEmpty)) {
                data = data.parallelStream().filter(StringUtils::isNotEmpty).collect(Collectors.toList());
                result.add(data.size());
                result.add(data.size());
                result.add(0);
            }
        }
        if (result.size() == 0) {
            result.addAll(Collections.nCopies(3, ""));
        }
        return result;
    }

    public static Object designFormat(Object design) {
        if (StringUtils.isNotEmpty(design)) {
            return Arrays.stream(design.toString().split("[^\\d.]")).filter(StringUtils::isNotEmpty).collect(Collectors.joining("/"));
        }
        return "";
    }

    public static List<List<Object>> dataSpaceSplit(List<Object> data, String[] designArr) {
        List<List<Object>> result = new ArrayList<>();
        if (ListUtils.isNotEmpty(data) && designArr != null) {
            /*首尾去空*/
            data = listTrim(data);
            String tmp = data.stream().map(StringUtils::handleNull).collect(Collectors.joining(","));
            tmp = tmp.replaceAll(",,,+", ",,");
            List<List<Object>> preliminary = Arrays.stream(tmp.split(",,")).map(CustomFunction::obj2ListNe).collect(Collectors.toList());
            /*默认容量16，小于12不会自动扩容*/
            LinkedHashMap<Integer, List<Object>> classify = new LinkedHashMap<>();
            for (int i = 0; i < preliminary.size(); i++) {
                int key = i % designArr.length;
                classify.merge(key, preliminary.get(i), (v1, v2) -> {
                    v1.addAll(v2);
                    return v1;
                });
            }
            result = new ArrayList<>(classify.values());
        }
        return result;
    }

    public static List<Object> listTrim(List<Object> list) {
        List<Object> result = new ArrayList<>();
        if (ListUtils.isNotEmpty(list)) {
            int end = list.size();
            for (int i = list.size() - 1; i >= 0; i--) {
                if (StringUtils.isNotEmpty(list.get(i)) || i == 0) {
                    end = i + 1;
                    break;
                }
            }
            int start = 0;
            for (int i = 0; i < list.size(); i++) {
                if (StringUtils.isNotEmpty(list.get(i))) {
                    start = i;
                    break;
                }
            }
            return list.subList(start, end);
        }
        return result;
    }


    public static final String ELE_CODE_REG = "(?<=E\\[)[^]]+(?=\\])";
    public static final Pattern P = Pattern.compile(ELE_CODE_REG);

    public static List<String> parseElementCode(String s) {
        List<String> result = new ArrayList<>();
        Matcher m = P.matcher(s);
        while (m.find()) {
            result.add(m.group().replace("'", ""));
        }
        return result;
    }

    public static String coefficient(String dev, double xN) {
        if (StringUtils.isNotEmpty(dev) && xN != 1) {
            String[] da = dev.split("[,，]");
            int scale = StringUtils.getScale(xN);
            dev = StringUtils.number2StringZero(Double.parseDouble(da[0]) * xN, scale) + "," + StringUtils.number2StringZero(Double.parseDouble(da[1]) * xN, scale);
        }
        return dev;
    }

    public static List<Object> b445random(Object hz, Object design, Object dev, Object failed, Object xN) {
        List<Object> measureOut = new ArrayList<>();
        String hzStr = StringUtils.handleNull(hz);
        String designStr = StringUtils.handleNull(design);
        String deviationStr = StringUtils.handleNull(dev);
        if (StringUtils.isNotEmpty(hzStr, designStr, deviationStr)) {
            String passStr = StringUtils.handleNull(failed);
            if (StringUtils.isEmpty(passStr)) {
                passStr = "0";
            }
            String[] rateIn = hzStr.split("/");
            rateIn = Arrays.stream(rateIn).filter(StringUtils::isNotEmpty).toArray(String[]::new);
            String[] designIn = designStr.split("/");
            designIn = Arrays.stream(designIn).filter(StringUtils::isNotEmpty).toArray(String[]::new);
            String[] deviationIn = deviationStr.split("/");
            deviationIn = Arrays.stream(deviationIn).filter(StringUtils::isNotEmpty).toArray(String[]::new);
            if (xN != null) {
                deviationIn = Arrays.stream(deviationIn).map(e -> coefficient(e, Double.parseDouble(xN.toString()))).toArray(String[]::new);
            }
            String[] passIn = passStr.split("/");
            passIn = Arrays.stream(passIn).filter(StringUtils::isNotEmpty).toArray(String[]::new);
            if (designIn.length > 0) {
                for (int i = 0; i < designIn.length; i++) {
                    String e = designIn[i];
                    int _hz = Integer.parseInt(i < rateIn.length ? rateIn[i] : rateIn[rateIn.length - 1]);
                    String _deviation = i < deviationIn.length ? deviationIn[i] : deviationIn[deviationIn.length - 1];
                    String _pass = i < passIn.length ? passIn[i] : passIn[passIn.length - 1];
                    int _scale = StringUtils.getScale(e, _deviation);
                    String delimiter = StringUtils.handleNull(matcherFindGroup("[^0-9.]", e, 0, false));
                    if (StringUtils.isEmpty(delimiter)) {
                        delimiter = CONCAT;
                    }
                    String[] _des = e.split("[" + delimiter + "]");
                    List<Object> _tmp = new ArrayList<>();
                    for (String _de : _des) {
                        List<Object> list;
                        double passD = Double.parseDouble(_pass);
                        /**大于0小于1则表示合格率，否则是不合格数量*/
                        double rate = (0 < passD && passD < 1) ? passD : (_hz - passD) / _hz;
                        list = cmv(_hz, _de, _deviation, rate, _scale);
                        if (ListUtils.isNotEmpty(list)) {
                            if (list.size() > _tmp.size()) {
                                _tmp.addAll(list);
                            } else {
                                for (int n = 0; n < _tmp.size(); n++) {
                                    /*假如设计值是DxD1这种形式，则需要把生成的实测值拼接起来*/
                                    _tmp.set(n, StringUtils.join(_tmp.get(n), list.get(n), delimiter));
                                }
                            }
                        }
                    }
                    measureOut.addAll(_tmp);
                }
            }
        }
        return measureOut;
    }

    /**
     * @return java.lang.Object
     * @Description 共检点合格点公式
     * @Param [data 数据, remark超出10个后的提示, design实际值, dev偏差值]
     * @Author yangyj
     * @Date 2022.02.11 10:09
     **/
    public static Object checkpoints(Object data, Object remark, Object design, Object dev, Object xN) {
        if (data != null) {
            if (data instanceof String && ((String) data).contains("NumberFormatException")) {
                return data;
            }
            Object[] R = ck(data, design, dev, xN);
            if (R[0] != null && R[1] != null && R[2] != null) {
                int checkpoints = Integer.parseInt(R[0].toString());
                int passpoints = Integer.parseInt(R[1].toString());
                List<Object> result = (List<Object>) R[2];
                boolean over = checkpoints > result.size();
                if (checkpoints <= 0) {
                    return "/";
                } else if (ListUtils.isNotEmpty(result) && result.size() <= 10 && !over) {
                    result = result.stream().map(obj -> {
                        if (StringUtils.isNumber(obj)) {
                            if (obj.toString().contains(".")) {
                                BigDecimal big = new BigDecimal(obj.toString());
                                String s = big.toString();
                                return s.replaceAll("(0+|\\.0+)$", "");
                            }
                        }
                        return obj;
                    }).collect(Collectors.toList());
                    return join(result, "、");
                } else {
                    if (StringUtils.isEmpty(remark)) {
                        remark = "共检点,合格点";
                    }
                    return remark.toString().replace("共检", "共检" + checkpoints).replace("合格", "合格" + passpoints);
                }
            }
        }
        return "/";
    }

    public static Object[] ck(Object data, Object design, Object dev, Object xN) {
        Object[] r = new Object[3];
        List<Object> result = new ArrayList<>();
        List<Object> datas = obj2List(removeEmpty(data));
        if (ListUtils.isNotEmpty(datas)) {
            int checkpoints = 0;
            int passpoints = 0;
            List<Object> designList = obj2List(design);
            if (ListUtils.isNotEmpty(designList)) {
                design = designList.get(0);
            }
            for (Object e : datas) {
                String s = handleNull(e);
                if (StringUtils.isNotEmpty(s)) {
                    if (containsZH(s)) {
                        Matcher m = RegexUtils.matcher("[\u4e00-\u9fa5]+(\\d+)\\D*合格(\\d+)\\D+", s);
                        if (m.find()) {
                            checkpoints += Integer.parseInt(m.group(1));
                            passpoints += Integer.parseInt(m.group(2));
                        }
                    } else {
                        result.add(s);
                    }
                }
            }
            result = result.stream().map(StringUtils::handleNull).map(String::trim).filter(e -> !StringUtils.isEquals("/", e)).collect(Collectors.toList());
            if (result.size() > 0) {
                List<Object> pl = passList(design, dev, result, xN);
                passpoints += pl.size();
                result = obj2List(result);
                checkpoints += result.size();
            } else {
                System.out.println();
            }
            r[0] = checkpoints;
            r[1] = passpoints;
            r[2] = result;
        }
        return r;
    }

    public static Object tree(List<String> treeNodes, String param) {
        if (CollectionUtil.isNotEmpty(treeNodes) && Func.isNotBlank(param)) {
            List<String> nodes = new ArrayList<>(treeNodes);
            //Collections.reverse(nodes);
            List<String> result = new ArrayList<>();
            param = param.trim().replaceAll("(?i:c)", "");
            List<String> list = Arrays.asList(param.split("[^.\\d]"));
            List<Integer> index = list.stream().map(Integer::parseInt).collect(Collectors.toList());
            for (Integer i : index) {
                if (i < nodes.size()) {
                    result.add(nodes.get(i));
                }
            }
            return String.join("", result);
        }
        return "";
    }

    public static Object tableNames(List<String> treeNodes) {
        if (CollectionUtil.isNotEmpty(treeNodes)) {
            List<String> nodes = new ArrayList<>(treeNodes);
            return nodes.stream().filter(e -> StringUtils.isNotEmpty(e) && !e.contains("A15")).map(e -> e.replaceAll("_(PL)?_\\d+$", "")).distinct().collect(Collectors.joining("\n"));
        }
        return "";
    }


    public static Object qrate(Object design, Object dev, Object data) {
        return qrate(design, dev, data, 0, 1);
    }

    public static Object qrate(Object design, Object dev, Object data, Object scale) {
        return qrate(design, dev, data, scale, 1);
    }

    /**
     * @return java.lang.Object
     * @Description Qualified rate of measured value 计算合格率
     * @Param [design： 设计值, dev：偏差范围或规定值, xN：偏差值单位转设计值单位倍率, data：数据, scale：保留小数位]
     * @Author yangyj
     * @Date 2022.01.14 09:56
     **/
    public static Object qrate(Object design, Object dev, Object data, Object scale, Object xN) {
        if (data != null && StringUtils.isNotEmpty(design, dev, xN)) {
            Object[] R = ck(data, design, dev, xN);
            if (R[0] != null && R[1] != null && Math.abs(Double.parseDouble(R[0].toString())) > 0) {
                String result = StringUtils.number2String(Double.parseDouble(R[1].toString()) * 100 / Double.parseDouble(R[0].toString()), scale);
                if (result.contains(".")) {
                    result = result.replaceAll("(0+|\\.0+)$", "");
                }
                return result;
            }
        }
        return "";
    }

    public static Object easyRate(Object data) {
        if (null != data) {
            List<Object> datas = obj2List(data);
            if (datas.stream().anyMatch(CustomFunction::containsZH)) {
                return 100;
            }
        }
        return "";
    }

    /**
     * @return java.lang.Object
     * @Description 检查内容
     * @Param [items, names]
     * @Author yangyj
     * @Date 2023.02.24 14:56
     **/
    public static Object checkContent(Object items, Object names) {
        if (items != null && names != null) {
            List<Object> result = new ArrayList<>();
            List<Object> content = obj2List(items);
            List<Object> list = obj2List(names);
            for (int i = 0; i < list.size(); i++) {
                Object cp = content.get(i);
                if (StringUtils.isNotEmpty(cp) && StringUtils.isNotEquals("/", cp)) {
                    result.add(list.get(i));
                }
            }
            if (ListUtils.isNotEmpty(result)) {
                return result.stream().map(StringUtils::handleNull).collect(Collectors.joining(StringPool.COMMA));
            }
        }
        return "";
    }

    /**
     * @return java.lang.Object
     * @Description 筛选合格的部分
     * @Param [design, dev, data, xN]
     * @Author yangyj
     * @Date 2022.02.12 13:59
     **/
    public static List<Object> passList(Object design, Object dev, Object data, Object xN) {
        List<Object> result = new ArrayList<>();
        List<Object> datas = obj2List(data);
        datas = (List<Object>) removeEmpty(datas);
        Double[] range = scopeParse(dev, design, xN);
        assert range != null;
        double finalMin = range[0];
        double finalMax = range[1];
        List<Object> l1 = datas.stream().map(StringUtils::handleNull).filter(e -> e.contains("*") || e.contains("X") || e.contains("x") || e.contains("×") || e.contains("/")).collect(Collectors.toList());
        if (ListUtils.isNotEmpty(l1)) {
            for (Object obj : l1) {
                String[] arr = obj.toString().split("[×xX*/]");
                if (Arrays.stream(Arrays.stream(arr).toArray()).allMatch(StringUtils::isNumber)) {
                    if (Arrays.stream(Arrays.stream(arr).toArray()).map(StringUtils::handleNull).map(Double::parseDouble).noneMatch(e -> e > finalMax || e < finalMin)) {
                        result.add(obj);
                    }
                }
            }
        }
        List<Object> l2 = datas.stream().filter(StringUtils::isNumber).map(StringUtils::handleNull).map(Double::parseDouble).filter(e -> e <= finalMax && e >= finalMin).collect(Collectors.toList());
        if (ListUtils.isNotEmpty(l2)) {
            result.addAll(l2);
        }
        return result;
    }



    public static Double[] scopeParse(Object dev, Object design, Object xN) {
        if (StringUtils.isNotEmpty(dev)) {
            Double[] result = new Double[2];
            double designD = Double.parseDouble(design.toString());
            double xND = Double.parseDouble(xN.toString());
            String devStr = dev.toString();
            devStr = devStr.replaceAll("[\\[\\]]+", "");
            double min = 0;
            double max = 0;
            devStr = devStr.replaceAll("\\s+", "");
            if (devStr.contains("≤") || devStr.contains("<=") || devStr.contains("<")) {
                devStr = devStr.replace("≤", "").replace("<=", "");
                max = designD + Double.parseDouble(devStr) * xND;
            } else if (devStr.contains("≥") || devStr.contains(">=") || devStr.contains(">")) {
                devStr = devStr.replace("≥", "").replace(">=", "");
                min = designD + Double.parseDouble(devStr) * xND;
                max = Double.MAX_VALUE;
            } else if (devStr.contains(",") || devStr.contains("，")) {
                String[] arr = devStr.split("[,，]");
                min = designD + Double.parseDouble(arr[0]) * xND;
                max = designD + Double.parseDouble(arr[1]) * xND;
            } else if (devStr.contains("%")) {
                devStr = devStr.replace("%", "");
                double devD = Math.abs(Double.parseDouble(devStr) * designD / 100);
                min = designD - devD;
                max = designD + devD;
            } else if (devStr.contains("±")) {
                devStr = devStr.replace("±", "");
                double devD = Math.abs(Double.parseDouble(devStr) * xND);
                min = designD - devD;
                max = designD + devD;
            }
            result[0] = min;
            result[1] = max;
            return result;
        }
        return null;
    }

    /**
     * @return java.util.List<java.lang.Object>
     * @Description specifiedRangeList
     * @Param [hz:频率, design：设计值, dev：偏差范围, xN 偏差范围单位和设计值单位的比值，例如毫米：厘米=0.1, scale：保存小数位, passRate：合格率[0,1]]
     * @Author yangyj
     * @Date 2022.03.31 09:16
     **/
    public static List<Object> rangeList(Object hz, Object design, Object dev, Object xN, Object scale, Object passRate) {
        List<Object> result = new ArrayList<>();
        if (StringUtils.isNotEmpty(design, dev, hz)) {
            if (StringUtils.isEmpty(scale)) {
                scale = 0;
            }
            if (StringUtils.isEmpty(passRate)) {
                passRate = 1;
            }
            if (StringUtils.isEmpty(xN)) {
                xN = 1;
            }
            Double[] range = scopeParse(dev, design, xN);
            int scaleI = Integer.parseInt(scale.toString());
            int min = 0, max = 0;
            assert range != null;
            if (range.length > 0) {
                min = (int) (range[0] * Math.pow(10, scaleI));
                max = (int) (range[1] * Math.pow(10, scaleI));
            }
            Random rd = new Random();
            int hzi = new BigDecimal(hz.toString()).multiply(new BigDecimal(passRate.toString())).setScale(0, ROUND_CEILING).intValue();
            for (int i = 0; i < hzi; i++) {
                BigDecimal tb = new BigDecimal(rd.nextInt(max - min + 1) + min).divide(BigDecimal.valueOf(Math.pow(10, scaleI)), scaleI, ROUND_HALF_UP);
                if (scaleI > 0) {
                    result.add(tb.doubleValue());
                } else {
                    result.add(tb.intValue());
                }

            }
            int total = StringUtils.handleObj2Integer(hz);
            if (total - hzi > 0) {
                for (int k = 0; k < total - hzi; k++) {
                    BigDecimal tb;
                    if (rd.nextBoolean()) {
                        tb = new BigDecimal(rd.nextInt(((max - min) / 2)) + max + 1).divide(BigDecimal.valueOf(Math.pow(10, scaleI)), scaleI, ROUND_HALF_UP);
                    } else {
                        tb = new BigDecimal(min - 1 - rd.nextInt(((max - min) / 2))).divide(BigDecimal.valueOf(Math.pow(10, scaleI)), scaleI, ROUND_HALF_UP);
                    }
                    if (scaleI > 0) {
                        result.add(tb.doubleValue());
                    } else {
                        result.add(tb.intValue());
                    }
                }
                if (ListUtils.isNotEmpty(result)) {
                    Collections.shuffle(result);
                }
            }
        }
        return result;
    }

    /**
     * @return java.util.List<java.lang.Object>
     * @Description obj 转List
     * @Param [obj]
     * @Author yangyj
     * @Date 2022.01.13 15:40
     **/
    public static List<Object> obj2List(Object obj) {
        List<Object> result = new ArrayList<>();
        if (obj != null) {
            List<Object> datas = new ArrayList<>();
            if (obj instanceof List) {
                datas = (List<Object>) obj;
            } else {
                datas.add(obj);
            }
            if (ListUtils.isNotEmpty(datas)) {
                for (Object e : datas) {
                    boolean fi = StringUtils.isNotEmpty(e) && !CustomFunction.containsZH(e.toString()) && (e.toString().contains("、") || e.toString().contains(",") || e.toString().contains(" ") || e.toString().contains("，"));
                    if (fi) {
                        String s = e.toString().trim();
                        if (s.contains(" ")) {
                            s = s.replaceAll("\\s+", "、");
                        }
                        Object[] bs = s.split("[、,，]");
                        result.addAll(Arrays.asList(bs));
                    } else {
                        result.add(e);
                    }
                }
            }
        }
        return result;
    }

    /**
     * @return java.lang.Object
     * @Description 对象转字符串，list取第一个对象
     * @Param [obj]
     * @Author yangyj
     * @Date 2022.02.11 15:14
     **/
    public static Object o2Str(Object obj) {
        String result = "";
        if (obj != null) {
            List<Object> datas = obj2List(obj);
            if (ListUtils.isNotEmpty(datas)) {
                return handleNull(datas.get(0));
            }
        }
        return result;
    }

    public static Object gfn(Object ob1, Object ob2, Object ob3) {
        return _gfn(ob1, ob2, ob3);
    }

    public static Object gfn(Object ob1, Object ob2) {
        return _gfn(ob1, ob2);
    }

    public static Object gfn(List<Object> list) {
        if (ListUtils.isNotEmpty(list)) {
            return _gfn(list.toArray());
        }
        return "";
    }

    /**
     * @Description 返回第一个不为空的对象
     * @Param
     * @Author yangyj
     * @Date 2022.01.04 13:57
     **/
    public static Object _gfn(Object... obs) {
        if (obs != null) {
            for (Object ob : obs) {
                if (ob instanceof List) {
                    List<Object> list = obj2List(ob);
                    if (ListUtils.isNotEmpty(list) && list.stream().anyMatch(StringUtils::isNotEmpty)) {
                        return ob;
                    }
                } else if (ob instanceof Map) {
                    if (MapUtils.isNotEmpty((Map) ob)) {
                        return ob;
                    }
                } else {
                    if (StringUtils.isNotEmpty(ob) && StringUtils.isNotEquals("/", ob)) {
                        return ob;
                    }
                }
            }
        }
        return null;
    }


    public Object checkItemName(List<Object> data, List<Object> names) {
        if (ListUtils.isNotEmpty(data) && ListUtils.isNotEmpty(names) && data.size() != names.size()) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < data.size(); i++) {
                List<Object> datas = obj2ListNe(data.get(i));
                if (datas.stream().anyMatch(e -> StringUtils.isNotEmpty(e) && StringUtils.isNotEquals("/", e))) {
                    sb.append(names.get(i)).append(",");
                }
            }
            if (sb.length() > 1) {
                sb.deleteCharAt(sb.length() - 1);
            }
            return sb.toString();
        }
        return "";
    }

    /**
     * @return java.lang.Object
     * @Description 三元运算 bool?o1:o2 ,默认返回空字符串
     * @Param [bool, o1, o2]
     * @Author yangyj
     * @Date 2021.01.29 13:54
     **/
    public static Object ifValObj(Object bool, Object o1, Object o2) {
        Boolean fi;
        if (bool instanceof Boolean) {
            fi = (Boolean) bool;
        } else {
            return "";
        }
        return fi ? o1 : o2;
    }

    /*太多写错公式名称的，应该是下面的方法名称比较容易接受*/
    public static Object isValObj(Object bool, Object o1, Object o2) {
        return ifValObj(bool, o1, o2);
    }

    /**
     * @return java.lang.Object
     * @Description 判断o1中是否包含字符串o2
     * @Param [o1, o2]
     * @Author yangyj
     * @Date 2021.01.29 14:04
     **/
    public static Object contains(Object o1, Object o2) {
        if (o1 != null && StringUtils.isNotEmpty(o2)) {
            List<Object> datas = obj2List(o1);
            return datas.stream().map(StringUtils::handleNull).anyMatch(e -> e.contains(o2.toString()));
        }
        return false;
    }

    /**
     * @return java.lang.Object
     * @Description 判断两个对象是否相等
     * @Param [o1, o2]
     * @Author yangyj
     * @Date 2021.08.23 16:51
     **/
    public static Object eq(Object o1, Object o2) {
        return StringUtils.isEquals(o1, o2);
    }


    /**
     * @return java.lang.Object
     * @Description 计算数据集的合格率
     * @Param [list：数据集, design：设计值, dev：偏差范围, scale：保存小数位]
     * @Author yangyj
     * @Date 2021.10.26 09:34
     **/
    public static Object getListTick(Object list, Object design, Object dev, Object scale) {
        if (list != null && design != null && StringUtils.isNotEmpty(dev)) {
            if (!StringUtils.isNumber(scale)) {
                scale = 0;
            }
            Matcher m = RegexUtils.matcher("(-?\\d+(\\.\\d+)?)[h|H]?[,|，](\\+?\\d+(\\.\\d+)?)[h|H]?", dev.toString().replaceAll("[(|)]", ""));
            if (list instanceof List && m.find()) {
                List<Object> arrayList = (ArrayList<Object>) list;
                double tick = 0;
                double designD = Double.parseDouble(handleNull(design));
                double h = 1;
                if (dev.toString().toUpperCase(Locale.ROOT).contains("H")) {
                    h = designD;
                }
                for (Object obj : arrayList) {
                    double dx = Double.parseDouble(handleNull(obj)) - designD;
                    if (Double.parseDouble(m.group(1)) * h <= dx && dx <= Double.parseDouble(m.group(3)) * h) {
                        tick++;
                    }
                }
                if (tick > 0) {
                    BigDecimal a = new BigDecimal(tick);
                    BigDecimal b = new BigDecimal(arrayList.size());

                    return a.divide(b, 8, ROUND_HALF_UP).multiply(new BigDecimal(100)).setScale(StringUtils.handleObj2Integer(scale.toString()), ROUND_HALF_UP);
                } else {
                    return "0";
                }
            }
        }
        return "";
    }


    /**
     * @return java.lang.Object
     * @Description 获取最后一个对象
     * @Param [list]
     * @Author yangyj
     * @Date 2021.08.09 14:37
     **/
    public static Object listAt(Object o, Object indexObj) {
        if (o == null) {
            return "";
        }
        if (o instanceof List) {
            List<Object> list = obj2ListNe(o);
            int index = 0;
            if (NumberUtil.isNumber(indexObj.toString())) {
                index = StringUtils.handObj2Integer(indexObj) - 1;
            } else if (StringUtils.isEquals("last", indexObj) || StringUtils.isEmpty(indexObj)) {
                index = list.size() - 1;
            }
            if (ListUtils.isNotEmpty(list)) {
                if (list.size() > index && index >= 0) {
                    return list.get(index);
                } else {
                    return list.get(list.size() - 1);
                }
            }
        } else {
            return o.toString();
        }
        return "";
    }


    /**
     * @Description 关键字转换
     * @Param [cn]
     * @Author yangyj
     * @Date 2022.10.10 17:24
     **/
    public static void formulaKeyWord(CalculateNode cn) {
        if (cn.type().equals(Token.OPERATOR_RESULT)) {
            OperatorResultNode opn = (OperatorResultNode) cn;
            formulaKeyWord(opn.getLeftOperand());
            formulaKeyWord(opn.getRightOperand());
        } else if (cn.type().equals(Token.METHOD_RESULT)) {
            StaticObjectMethodNode cmn = (StaticObjectMethodNode) cn;
            CalculateNode[] array = cmn.getArgsNodes();
            if (ArrayUtil.isNotEmpty(array)) {
                for (int i = 0; i < array.length; i++) {
                    CalculateNode c = array[i];
                    if (c instanceof StaticObjectMethodNode) {
                        formulaKeyWord(c);
                    } else if (c instanceof VariableNode) {
                        if (KEYWORD_SET.contains(c.literals())) {
                            /*关键字需要包裹起来*/
                            array[i] = new VariableNode("'" + c.literals() + "'");
                        }
                    }
                }
            }
            cmn.setArgsNodes(array);
        }

    }

    public static List<Object> obj2ListNe(Object obj) {
        List<Object> list = obj2List(obj);
        return list.parallelStream().filter(StringUtils::isNotEmpty).collect(Collectors.toList());
    }

    /*obj2ListNe别名*/
    public static List<Object> objToListNe(Object obj) {
        return obj2ListNe(obj);
    }


    /**
     * @return java.lang.Object
     * @Description 过滤掉List中的空对象
     * @Param [o]
     * @Author yangyj
     * @Date 2021.07.28 11:16
     **/
    public static Object removeEmpty(Object o) {
        List<Object> result = new ArrayList<>();
        if (o instanceof List) {
            for (Object e : (List<Object>) o) {
                if (StringUtils.isNotEmpty(e)) {
                    result.add(e);
                }
            }
        } else {
            result.add(o);
        }
        return result;
    }

    /**
     * @return
     * @Description 设置保留小数位
     * @Param
     * @Author yangyj
     * @Date 2021.12.31 17:14
     **/
    public static Object setScale(Object o, Object scale) {
        if (StringUtils.isNumber(scale) && o != null) {
            if (o instanceof List || o.toString().contains(",") || o.toString().contains("、")) {
                List<Object> result = new ArrayList<>();
                List<Object> tmp = obj2ListNe(o);
                for (Object e : tmp) {
                    if (StringUtils.isNumber(e)) {
                        result.add(StringUtils.number2String(e, scale));
                    } else {
                        result.add("");
                    }
                }
                if (o instanceof String) {
                    String delimiter = "、";
                    if (o.toString().contains(",")) {
                        delimiter = ",";
                    }
                    return result.stream().map(StringUtils::handleNull).collect(Collectors.joining(delimiter));
                }
                return result;
            } else {
                if (StringUtils.isNumber(o)) {
                    return StringUtils.number2String(o, scale);
                }
            }
        }
        return "";
    }

    public static Object abs(Object o) {
        /**
         * @Description 测试
         * @Param [o]
         * @return java.lang.Object
         * @Author yangyj
         * @Date 2022.03.21 15:43
         **/
        if (o != null) {
            if (o instanceof List) {
                List<Object> result = new ArrayList<>();
                List<Object> datas = obj2List(o);
                if (ListUtils.isNotEmpty(datas)) {
                    for (Object e : datas) {
                        if (StringUtils.isNotEmpty(e)) {
                            result.add(e.toString().replaceAll("^-", ""));
                        }
                    }
                }
                return result;
            } else {
                return o.toString().replaceAll("^-", "");
            }
        }
        return null;
    }

    /**
     * @return java.lang.Object
     * @Description 返回正则式匹配内容
     * @Param [regex：正则式, value：匹配的字符串, i：group(i), g:是否返回全局搜索，全局搜索返回的是列表]
     * @Author yangyj
     * @Date 2021.01.08 16:31
     **/
    public static Object matcherFindGroup(String regex, String value, int i, boolean g) {
        Matcher m = RegexUtils.matcher(regex, value);
        List<Object> result = new ArrayList<>();
        while (m.find()) {
            result.add(m.group(i));
        }
        if (ListUtils.isNotEmpty(result)) {
            if (g) {
                return result;
            } else {
                return result.get(0);
            }
        }
        return null;
    }

    /**
     * @return java.lang.Object
     * @Description 放大缩小
     * @Author yangyj
     * @Date 2022.01.14 14:17
     **/
    public static Object xN(Object o, Object xN) {
        String cur = "";
        try {
            if (StringUtils.isNotEmpty(o) && StringUtils.isNumber(xN)) {
                double xND = Double.parseDouble(xN.toString());
                List<Object> outList = new ArrayList<>();
                if (o instanceof List) {
                    List<Object> datas = obj2ListNe(o);
                    for (Object e : datas) {
                        if (StringUtils.isNotEmpty(e)) {
                            String[] as = e.toString().split("[^\\d.-]");
                            Object m = matcherFindGroup("[^\\d.-]", e.toString(), 0, false);
                            StringBuilder d = new StringBuilder();
                            for (int i = 0; i < as.length; i++) {
                                String s = as[i];
                                cur = s;
                                int scale = (int) Math.max(getScale(s) - Math.log10(xND), 0);
                                d.append(StringUtils.number2String(Double.parseDouble(s) * xND, scale)).append(i != as.length - 1 && m != null ? m : "");
                            }
                            outList.add(d.toString());
                        }
                    }
                    if (ListUtils.isNotEmpty(outList)) {
                        return outList;
                    }
                } else {
                    List<Object> datas = Arrays.asList(o.toString().split("[、， ,]"));
                    Matcher m = RegexUtils.matcher("[、， ,]", o.toString());
                    String s = "、";
                    if (m.find()) {
                        s = handleNull(m.group());
                    }
                    if (ListUtils.isNotEmpty(datas)) {
                        for (Object e : datas) {
                            if (StringUtils.isNotEmpty(e)) {
                                int scale = (int) Math.max(getScale(s) - Math.log10(xND), 0);
                                cur = e.toString();
                                outList.add(StringUtils.number2String(Double.parseDouble(e.toString()) * xND, scale));
                            }
                        }
                    }
                    if (ListUtils.isNotEmpty(outList)) {
                        return StringUtils.join(outList.stream().map(StringUtils::handleNull).collect(Collectors.toList()), s);
                    }
                }
            }
        } catch (NumberFormatException e) {
            e.printStackTrace();
            String error = "";
            if (e.getMessage().contains("multiple points")) {
                error = cur + "包含多个小数点";
            } else {
                error = cur;
            }
            return "NumberFormatException(数字格式异常，请检查)" + error;
        }
        return "";
    }

/*    public static void main(String[] args) {
        List<Object> list = Arrays.asList(1,-1,"-4*8");
        obj2ListNe(xN(list,10)).forEach(System.out::println);
    }*/

    public static Object repeat(Object data) {
        List<Object> result = new ArrayList<>();
        if (data != null) {
            List<Object> list = obj2List(removeEmpty(data));
            /*外观质量，这种中文描述去重*/
            if (list.stream().filter(CustomFunction::containsZH).anyMatch(e -> e.toString().contains("\n"))) {
                AtomicInteger index = new AtomicInteger(1);
                result = list.stream().flatMap(e -> Arrays.stream(e.toString().split("\\n+"))).map(String::trim).map(e -> e.replaceAll("^\\d+[、.\\s]*", "")).distinct().map(e -> (index.getAndIncrement()) + "、" + e + "\n").collect(Collectors.toList());
            } else {
                result = list.stream().distinct().collect(Collectors.toList());
            }
        }
        return result;
    }

    public static List<Object> diffusion(List<Object> data) {
        List<Object> result = new ArrayList<>();
        if (data != null) {
            Optional<Object> op = data.stream().filter(StringUtils::isNotEmpty).findFirst();
            if (op.isPresent()) {
                Object copy = op.get();
                return data.stream().map(e -> StringUtils.isEmpty(e) ? copy : e)
                        .collect(Collectors.toList());
            }
        }
        return result;
    }


    /**
     * @return java.lang.Object
     * @Description 截取list subList(list,1,5) 返回list的第1到第5个元素
     * @Param [o]
     * @Author yangyj
     * @Date 2021.07.28 11:16
     **/
    public static Object subList(Object o, Object start, Object end) {
        List<Object> result = new ArrayList<>();
        if (o instanceof List) {
            result = (List<Object>) o;
            int s = StringUtils.handleObj2Integer(start);
            int e = StringUtils.handleObj2Integer(end);
            s = Math.max(s, 1);
            if (e <= 0) {
                e = result.size();
            }
            return result.subList(s - 1, e);
        }
        return result;
    }

    /**
     * @return java.lang.Object
     * @Description 获取G8测点偏差
     * @Param [cd, pc]
     * @Author yangyj
     * @Date 2022.02.25 11:05
     **/
    public static Object g8dx(Object cd, Object pc) {
        if (cd != null && pc != null) {
            List<Object> result = new ArrayList<>();
            List<Object> stakes = obj2List(cd);
            List<Object> dx = obj2List(pc);
            if (ListUtils.isNotEmpty(stakes) && dx.size() >= stakes.size()) {
                Object bmd = stakes.get(0);
                if (StringUtils.isNotEmpty(bmd)) {
                    for (int i = 0; i < stakes.size(); i++) {
                        Object cp = stakes.get(i);
                        if (StringUtils.isNotEmpty(cp) && StringUtils.isNotEquals(bmd, cp)) {
                            Matcher m = RegexUtils.matcher("(?i)zd\\d+", cp.toString());
                            if (!m.find()) {
                                result.add(dx.get(i));
                            }
                        }
                    }
                    return result;
                }
            }
        }
        return "";
    }

    public static Object g8stakes(Object cd) {
        if (cd != null) {
            List<Object> result = new ArrayList<>();
            List<Object> stakes = obj2List(cd);
            if (ListUtils.isNotEmpty(stakes)) {
                Object bmd = stakes.get(0);
                if (StringUtils.isNotEmpty(bmd)) {
                    for (Object cp : stakes) {
                        if (StringUtils.isNotEmpty(cp) && StringUtils.isNotEquals(bmd, cp)) {
                            Matcher m = RegexUtils.matcher("(?i)zd\\d+", cp.toString());
                            if (!m.find()) {
                                result.add(cp);
                            }
                        }
                    }
                    return result;
                }
            }
        }
        return "";
    }

    public static List<Object> g8c103(Object cd, Object sj, Object sc, Object dx) {
        List<Object> result = new ArrayList<>();
        if (cd != null && sj != null && sc != null && dx != null) {
            List<Object> cds = obj2List(cd);
            List<Object> sjs = obj2List(sj);
            List<Object> scs = obj2List(sc);
            List<Object> dxs = obj2List(dx);
            int min = Math.min(Math.min(sjs.size(), scs.size()), dxs.size());
            if (ListUtils.isNotEmpty(cds) && min >= cds.size()) {
                Object bmd = cds.get(0);
                if (StringUtils.isNotEmpty(bmd)) {
                    for (int i = 0; i < cds.size(); i++) {
                        Object cp = cds.get(i);
                        if (StringUtils.isNotEmpty(cp) && StringUtils.isNotEquals(bmd, cp)) {
                            Matcher m = RegexUtils.matcher("(?i)zd\\d+", cp.toString());
                            if (!m.find()) {
                                if (StringUtils.isNumber(cp)) {
                                    result.add("");
                                    result.add("");
                                    result.add("");
                                    result.add(dxs.get(i));
                                } else {
                                    result.add(sjs.get(i));
                                    result.add(scs.get(i));
                                    result.add(dxs.get(i));
                                    result.add("");
                                }
                            }
                        }
                    }
                }
            }
        }
        return result;
    }

    public static List<Object> g8zzds(Object cd, Object dx, Object fi) {
        List<Object> result = new ArrayList<>();
        if (cd != null && dx != null) {
            List<Object> cds = obj2List(cd);
            List<Object> dxs = obj2List(dx);
            boolean bol = (boolean) fi;
            int min = dxs.size();
            if (ListUtils.isNotEmpty(cds) && min >= cds.size()) {
                Object bmd = cds.get(0);
                List<String> l1 = new ArrayList<>();
                List<String> l2 = new ArrayList<>();
                List<String> l3 = new ArrayList<>();
                List<String> dyn;
                if (bol) {
                    dyn = l3;
                } else {
                    dyn = l2;
                }
                if (StringUtils.isNotEmpty(bmd)) {
                    for (int i = 0; i < cds.size(); i++) {
                        Object cp = cds.get(i);
                        if (StringUtils.isNotEmpty(cp) && StringUtils.isNotEquals(bmd, cp)) {
                            Matcher m = RegexUtils.matcher("(?i)zd\\d+", cp.toString());
                            if (!m.find()) {
                                if (StringUtils.isNumber(cp)) {
                                    dyn.add(handleNull(dxs.get(i)));
                                } else {
                                    l1.add(handleNull(dxs.get(i)));
                                }
                            }
                        }
                    }
                    result.add(StringUtils.join(l1, ","));
                    result.add(StringUtils.join(l2, ","));
                    result.add(StringUtils.join(l3, ","));
                }
            }
        }
        return result;
    }

    public static List<Object> gcc(Object zh, Object sj, Object sc, Object dx, Object mode) {
        List<Object> result = new ArrayList<>();
        if (zh != null && sj != null && sc != null && dx != null) {
            List<Object> cds = obj2List(zh);
            List<Object> sjs = obj2List(sj);
            List<Object> scs = obj2List(sc);
            List<Object> dxs = obj2List(dx);
            int min = Math.min(Math.min(dxs.size(), sjs.size()), scs.size());
            if (ListUtils.isNotEmpty(cds) && min >= cds.size()) {
                Object bmd = cds.get(0);
                if (StringUtils.isNotEmpty(bmd)) {
                    for (int i = 0; i < cds.size(); i++) {
                        Object cp = cds.get(i);
                        if (StringUtils.isNotEmpty(cp) && StringUtils.isNotEquals(bmd, cp)) {
                            Matcher m = RegexUtils.matcher("(?i)zd\\d+", cp.toString());
                            if (!m.find()) {
                                if (StringUtils.isEquals(mode, 0)) {
                                    if (!Pattern.matches(".+(?i)v$", cp.toString())) {
                                        result.add(sjs.get(i));
                                        result.add(scs.get(i));
                                        result.add(dxs.get(i));
                                    }
                                } else if (StringUtils.isEquals(mode, 1)) {
                                    if (Pattern.matches(".+(?i)v$", cp.toString())) {
                                        result.add(sjs.get(i));
                                        result.add(scs.get(i));
                                        result.add(dxs.get(i));
                                    }
                                }

                            }
                        }
                    }
                }
            }
        }
        return result;
    }


    /**
     * @return java.lang.Object
     * @Description list 去头尾
     * @Param [o]
     * @Author yangyj
     * @Date 2021.12.31 14:53
     **/
    public static Object removeHT(Object o) {
        List<Object> result = new ArrayList<>();
        if (o instanceof List) {
            result = (List<Object>) o;
            if (result.size() > 2) {
                int end = result.size();
                for (int i = result.size() - 1; i > 1; i--) {
                    if (StringUtils.isNotEmpty(result.get(i))) {
                        end = i;
                        break;
                    }
                }
                return subList(result, 2, end);
            }
        }
        return result;
    }


    public static Object removeByReg(Object o, Object reg) {
        List<Object> result = new ArrayList<>();
        if (o instanceof List && StringUtils.isNotEmpty(reg)) {
            result = (List<Object>) o;
            return result.stream().map(StringUtils::handleNull).filter(e -> !Pattern.matches(reg.toString(), e)).collect(Collectors.toList());
        }
        return result;
    }

    /**
     * @return java.lang.Object
     * @Description 获取动态行某列内容
     * @Param [data, field]
     * @Author yangyj
     * @Date 2022.01.08 10:02
     **/
    public static Object getColumn(Object data, Object field) {
        if (StringUtils.isNotEmpty(field)) {
            List<HashMap<String, Object>> _data = objToArray(data);
            if (ListUtils.isNotEmpty(_data)) {
                return _data.stream().map(e -> e.get(field.toString())).collect(Collectors.toList());
            }
        }
        return data;
    }

    /**
     * @return java.lang.Object
     * @Description 合并多个list
     * @Param [listArr]
     * @Author yangyj
     * @Date 2021.12.31 15:10
     **/
    public static Object mergeList(Object l1, Object l2) {
        return _mergeList(l1, l2);
    }

    public static Object mergeList(Object l1, Object l2, Object l3) {
        return _mergeList(l1, l2, l3);
    }

    public static Object mergeList(Object l1, Object l2, Object l3, Object l4) {
        return _mergeList(l1, l2, l3, l4);
    }

    public static Object mergeList(Object l1, Object l2, Object l3, Object l4, Object l5) {
        return _mergeList(l1, l2, l3, l4, l5);
    }

    public static Object mergeList(Object l1, Object l2, Object l3, Object l4, Object l5, Object l6) {
        return _mergeList(l1, l2, l3, l4, l5, l6);
    }

    public static Object mergeList(Object l1, Object l2, Object l3, Object l4, Object l5, Object l6, Object l7) {
        return _mergeList(l1, l2, l3, l4, l5, l6, l7);
    }

    public static Object mergeList(Object l1, Object l2, Object l3, Object l4, Object l5, Object l6, Object l7, Object l8) {
        return _mergeList(l1, l2, l3, l4, l5, l6, l7, l8);
    }

    public static Object _mergeList(Object... listArr) {
        List<Object> result = new ArrayList<>();
        if (listArr != null && listArr.length >= 2) {
            List<List<Object>> tmp = new ArrayList<>();
            int max = 0;
            for (Object o : listArr) {
                List<Object> list = Collections.singletonList("");
                if (o instanceof List) {
                    list = (List<Object>) o;
                    max = Math.max(max, list.size());
                }
                tmp.add(list);
            }
            if (ListUtils.isNotEmpty(tmp)) {
                for (int i = 0; i < max; i++) {
                    for (List<Object> _l : tmp) {
                        if (_l.size() > i) {
                            result.add(_l.get(i));
                        } else {
                            result.add("");
                        }
                    }
                }
            }
        }
        return result;
    }



    /**
     * @return java.lang.Object
     * @Description list 转 string
     * @Param [o, separator:分隔符]
     * @Author yangyj
     * @Date 2021.07.28 15:50
     **/

    public static Object join(Object o1, Object separator) {
        Optional<Object> op = Optional.ofNullable(o1);
        if (op.isPresent()) {
            String s = StringUtils.handleNull(separator);
            if (StringUtils.isEmpty(s)) {
                s = "、";
            }
            return op.map(CustomFunction::obj2ListNe).orElse(Collections.singletonList("")).stream().map(StringUtils::handleNull).collect(Collectors.joining(s));
        }
        ;
        return "";
    }


    /**
     * @return java.lang.Object
     * @Description String 转List
     * @Param [o, separator]
     * @Author yangyj
     * @Date 2021.12.03 15:09
     **/
    public static Object split(Object o, Object separator) {
        if (StringUtils.isNotEmpty(o, separator)) {
            System.out.println(separator);
            String[] arr = o.toString().split(separator.toString());
            return Arrays.stream(arr).collect(Collectors.toList());
        }
        return null;
    }

    public static Object split(Object o) {
        return split(o, "/|,|、|，|；|;|\\\\|(\\s+)");
    }

    /**
     * @Description 删除下标为index的元素
     * @Param [o, index]
     * @Author yangyj
     * @Date 2021.07.28 15:52
     **/
    public static void rem(Object o, Object index) {
        if (o instanceof List && StringUtils.isNumber(index)) {
            ((List<Object>) o).remove(StringUtils.handleObj2Integer(index).intValue());
        }
    }

    /**
     * @return java.lang.Object
     * @Description 根据百分比返回子集list内容
     * @Param [obj：数据源, percent：0-100]
     * @Author yangyj
     * @Date 2020.12.04 09:24
     **/
    public static Object getListPercent(Object obj, Object percent) {
        if (obj != null && percent != null) {
            if (obj instanceof List) {
                ArrayList<Object> list = (ArrayList<Object>) obj;
                Collections.shuffle(list);
                int n = (int) Math.round((Double.parseDouble(percent.toString()) / 100) * list.size());
                if (n <= list.size()) {
                    return list.subList(0, n);
                }
                return list;
            }
        }
        return "";
    }





    /**
     * @return java.util.ArrayList<java.util.HashMap < java.lang.String, java.lang.Object>>
     * @Description 把Object 转换成 ArrayList<HashMap<String, Object>>
     * @Param [obj]
     * @Author yangyj
     * @Date 2020.12.11 09:44
     **/
    public static List<HashMap<String, Object>> objToArray(Object obj) {
        if (obj instanceof ArrayList) {
            return (List<HashMap<String, Object>>) obj;
        } else if (obj instanceof HashMap) {
            List<HashMap<String, Object>> array = new ArrayList<>();
            HashMap<String, Object> map = (HashMap<String, Object>) obj;
            if (map.size() > 0) {
                array.add(map);
            }
            return array;
        }
        return null;
    }


    public static Object dXd(Object design, Object data) {
        return dXd(design, data, 1, 0);
    }

    public static Object dXd(Object design, Object data, Object xN, Integer mode) {
        int scale = 0;
        if (StringUtils.isNotEmpty(design, data, xN)) {
            scale = getScale(design, data);
            scale = (int) (scale - Math.log10(Double.parseDouble(xN.toString())));
        }
        if (StringUtils.isEmpty(mode)) {
            mode = 0;
        }
        return dXd(design, data, xN, scale, mode);
    }

    /**
     * @return java.lang.Object
     * @Description 求偏差公式  支持AXA-BXB=DXD或者A-B=D的格式
     * @Param [design:设计值, data：实测值, xN：倍率, scale：保留小数位,mode:1乘法，其它默认减法]
     * @Author yangyj
     * @Date 2022.01.20 09:45
     **/
    public static Object dXd(Object design, Object data, Object xN, Object scale, Integer mode) {
        if (StringUtils.isNotEmpty(design, data)) {
            if (StringUtils.isEmpty(xN)) {
                xN = 1;
            }
            if (StringUtils.isEmpty(scale)) {
                scale = 0;
            }
            String delimiter = handleNull(matcherFindGroup("[^0-9.]", design.toString(), 0, false));
            if (StringUtils.isEmpty(delimiter)) {
                delimiter = CONCAT;
            }
            String[] dArr = handleNull(design).split("[" + delimiter + "]");
            String[] bArr = handleNull(data).split("[" + delimiter + "]");
            Object _dx = null;
            for (int n = 0; n < dArr.length; n++) {
                BigDecimal a = new BigDecimal(dArr[n]);
                BigDecimal b = new BigDecimal(bArr[n]);
                String _data;
                if (StringUtils.isEquals(1, mode)) {
                    _data = b.multiply(a).multiply(new BigDecimal(xN.toString())).setScale(Integer.parseInt(scale.toString()), ROUND_HALF_UP).toString();
                } else {
                    _data = b.subtract(a).multiply(new BigDecimal(xN.toString())).setScale(Integer.parseInt(scale.toString()), ROUND_HALF_UP).toString();
                }
                if (StringUtils.isNotEmpty(_dx)) {
                    _dx = StringUtils.join(_dx, _data, delimiter);
                } else {
                    _dx = _data;
                }
            }
            return _dx;
        }
        return "";
    }


    /**
     * @return java.lang.Object
     * @Description 总体标准差
     * @Param [data, scale]
     * @Author yangyj
     * @Date 2022.04.14 11:32
     **/
    public static Object sd(Object data, Object scale) {
        if (data != null && StringUtils.isNumber(scale)) {
            data = removeEmpty(data);
            List<Object> datas = obj2List(data);
            int total = datas.size();
            List<String> _datas = datas.stream().map(StringUtils::handleNull).collect(Collectors.toList());
            double avgVal = _datas.stream().mapToDouble(Double::parseDouble).average().orElse(0D);
            double result = Math.sqrt(_datas.stream().mapToDouble(Double::parseDouble).map(e -> Math.pow(e - avgVal, 2)).sum() / total);
            return StringUtils.number2String(result, scale);
        }
        return "";
    }


}