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.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.springblade.common.utils.BaseUtils;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.tool.utils.*;
import org.springblade.manager.bean.SpringContextHolder;
import org.springblade.manager.dto.ParamElements;
import org.springblade.manager.entity.WbsTreeContract;
import org.springblade.manager.utils.NumberStringSubtraction;
import org.springblade.manager.utils.RandomNumberHolder;
import org.springframework.jdbc.core.JdbcTemplate;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

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


/**
 * @author yangyjT(com.mixsmart.utils.CustomFunction).dateAfter(T(com.mixsmart.utils.CustomFunction).dateMax(E['m_20220928150650_1575019183173795840:key_9']),28)
 */
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.isNotEmpty(n)) {
            List<String> dateList =new ArrayList<>();
            if (date instanceof List) {
                 dateList = ((List<String>)date);
            }else{
                dateList.add(date.toString());
            }
            LinkedList<Integer> offSet = new LinkedList<>();
            if (n instanceof List) {
                offSet.addAll((List<Integer>)n);
            }else{
                offSet.add(StringUtils.handObj2Integer(n));
            }
            return dateOffset(dateList,offSet);
        }
        return "";
    }



    public static Object dateOffset(List<String> dateList,LinkedList<Integer> offSet){
            List<String> result = new ArrayList<>();
            if(ListUtils.isNotEmpty(dateList)&&ListUtils.isNotEmpty(offSet)){
                for(int i=0;i<dateList.size();i++){
                    String d= dateList.get(i).replaceAll("[\"']", "");;
                    if(StringUtils.isNotEmpty(d)) {
                        if(d.contains(",")){
                            String[] arr=d.replaceAll("[\\[\\]\\s]+","").split(",");
                            d=arr[arr.length-1];
                        }
                        Integer n = StringUtils.handObj2Integer(offSet.size() > i ? offSet.get(i) : offSet.getLast());
                        // 日期需要正确的格式，需要判断
                        DateTime dt = new DateTime(d);
                        dt.offset(DateField.HOUR_OF_DAY, 24 * n);
                        result.add(dt.toString(DatePattern.CHINESE_DATE_PATTERN));
                    }
                }
            }
            return result;
    }

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

    //天气 - 气温
    public static Object weathertem( Object dateObj,Map<String,Object> map){
        if(dateObj!=null&&map!=null){
            List<Object> date=obj2ListObj(dateObj);
            return  date.stream().map(StringUtils::handleNull).filter(StringUtils::isNotEmpty).map(e->map.get(new DateTime(FormulaUtils.range2end(e)).toString(DatePattern.NORM_DATE_PATTERN))).collect(Collectors.toList());
        }
        return "";
    }

    // 获取最大温度
    public static Object maxtembydate( Object dateObj,Map<String,Object> map){
        if(dateObj!=null&&map!=null){
            List<Object> date=obj2ListObj(dateObj);
            return  date.stream().map(StringUtils::handleNull).filter(StringUtils::isNotEmpty).map(e->map.get(new DateTime(FormulaUtils.range2end(e)).toString(DatePattern.NORM_DATE_PATTERN))).collect(Collectors.toList());
        }
        return "";
    }

    // 获取最小温度
    public static Object mintembydate( Object dateObj,Map<String,Object> map){
        if(dateObj!=null&&map!=null){
            List<Object> date=obj2ListObj(dateObj);
            return  date.stream().map(StringUtils::handleNull).filter(StringUtils::isNotEmpty).map(e->map.get(new DateTime(FormulaUtils.range2end(e)).toString(DatePattern.NORM_DATE_PATTERN))).collect(Collectors.toList());
        }
        return "";
    }

    // 获取星期几
    public static Object weekbydate( Object dateObj,Map<String,Object> map){
        if(dateObj!=null&&map!=null){
            List<Object> date=obj2ListObj(dateObj);
            return  date.stream().map(StringUtils::handleNull).filter(StringUtils::isNotEmpty).map(e->map.get(new DateTime(FormulaUtils.range2end(e)).toString(DatePattern.NORM_DATE_PATTERN))).collect(Collectors.toList());
        }
        return "";
    }

    // 获取最大温度
    public static Object maxminbydate( Object dateObj,Map<String,Object> map){
        if(dateObj!=null&&map!=null){
            List<Object> date=obj2ListObj(dateObj);
            return  date.stream().map(StringUtils::handleNull).filter(StringUtils::isNotEmpty).map(e->map.get(new DateTime(FormulaUtils.range2end(e)).toString(DatePattern.NORM_DATE_PATTERN))).collect(Collectors.toList());
        }
        return "";
    }

    public static List<Object> obj2ListObj(Object input) {
        if (input == null) {
            return Collections.emptyList();
        }
        List<Object> result = new ArrayList<>();
        if (input instanceof List<?>) {
            result.addAll((List<?>) input);
        } else if (StringUtils.isNotEmpty(input)) {
            result.add(input);
        }
        return result;
    }


    public static Object dateMax(Object range) {
        return convert(range,false);
    }

    public static Object dateMin(Object range) {
      return convert(range,true);
    }

    public static  Object convert(Object range,boolean isAsc){
        if (Func.isNotEmpty(range)) {
            if(range instanceof List){
               List<Object> ranges= (List<Object>) range;
                if( Func.isNotEmpty(ranges)) {
                   return ranges.stream().filter(Func::isNotEmpty).map(e->{
                        String[] s = Func.toStr(e).replaceAll("[\\[\\]\\s\\\\]+", "").split(",");
                        if(s.length>=2){
                            return dateCp(s[0], s[1], isAsc);
                        }else if(s.length==1){
                            return s[0];
                        }
                        return "";
                    }).collect(Collectors.toList());
                }
            } else{
                String[] s = Func.toStr(range).replaceAll("[\\[\\]\\s]+", "").split(",");
                return dateCp(s[0], s[1], isAsc);
            }
        }
        return StringPool.EMPTY;
    }

    private static Object dateCp(Object d1, Object d2, Boolean isAsc) {
        if (d1 != null && d2 != null) {
            Map<DateTime, Object> map = new HashMap<>();
            String day1 = d1.toString();
            day1=day1.replace("年","-");
            day1=day1.replace("月","-");
            if(day1.indexOf("日")>0){
                day1= day1.substring(0,day1.indexOf("日"));
            }
            String day2 = d2.toString();
            day2= day2.replace("年","-");
            day2= day2.replace("月","-");
            if(day2.indexOf("日")>0){
                day2=day2.substring(0,day2.indexOf("日"));
            }
            day1=day1.replace("\"", "");
            day2=day2.replace("\"", "");
            DateTime dt1 = new DateTime(day1);
            DateTime dt2 = new DateTime(day2);
            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+", "")).filter(s->!RegexUtil.match("/+",s)).collect(Collectors.toList());
            if(data.size()>0) {
                return 100 * ((double) data.stream().filter(e -> StringUtils.isEquals(e, cp)).count()) / (double) data.size();
            }
        }
        return "";
    }

/*    public static void main(String[] args) {
        List<Object> list = Arrays.asList("优良","优良","优良","/");
        System.out.println(proportion(list,"优良"));
    }*/

    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).map(o->o.replace("%","")).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(List<Object> rate, List<Object> level) {
        if (ListUtils.isNotEmpty(rate)&&ListUtils.isNotEmpty(level)) {
            return StringUtils.obj2Double(StringUtils.handleNull(rate.get(0)).trim()) > 50 && "优良".equals(StringUtils.handleNull(level.get(0)).trim()) ? "优良" : "合格";
        }
        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 static String passRateDisplay(Object rates){
        List<Object> rate =obj2ListNe(rates);
        if(Func.isNotEmpty(rate)&&rate.stream().anyMatch(StringUtils::isNotEmpty)){
           Optional<Object> op= rate.stream().filter(s->s!=null&&RegexUtil.match("[\\d.]+%?",s.toString())).findAny();
            return op.map(o ->{
                o=o.toString().replace("%","");
                int scale=1;
                double x=BaseUtils.obj2DoubleZero(o);
                if(x>=100.0){
                   scale=0;
                   if(x>100.0){
                       o=100;
                   }
                }
              return   StringUtils.number2StringZero(o, scale) + "%";
            }).orElseGet(()->rate.get(0).toString());
        }
        return "/";
    }







    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 void main(String[] args) {
       *//* LocalDateTime ldt1= LocalDateTime.now();
        LocalDateTime ldt2=ldt1.minusDays(-1);
        LocalDateTime ldt3=ldt1.minusDays(120L);
        System.out.println(daysPassed(ldt2,ldt1));
        System.out.println(daysPassed(ldt3,ldt1));
        System.out.println(hoursPassed(ldt2,ldt1));
        System.out.println(hoursPassed(ldt3,ldt1));
        System.out.println(minutesPassed(ldt2,ldt1));
        System.out.println(minutesPassed(ldt3,ldt1));*//*
      *//*  LocalDate t1 = LocalDate.of(2023, 1, 1);
        LocalDate t2 = LocalDate.of(2023, 1, 1);t2=t2.plusDays(1);
        System.out.println(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) {
        List<Object> result=new ArrayList<>();
        if (t1 != null && t2 != null && StringUtils.isNotEmpty(mode) && StringUtils.isNotEmpty(scale) && StringUtils.isNotEmpty(format)) {
            LinkedList<Object> list1,list2;
            if(t1 instanceof  List){
                 list1 = new LinkedList<Object>((List) t1);
            }else{
                 list1= new LinkedList<>();
                 list1.add(t1);
            }
            if(t2 instanceof  List){
                list2 = new LinkedList<Object>((List) t2);
            }else{
                list2= new LinkedList<>();
                list2.add(t2);
            }
            int n =Math.max(list1.size(),list2.size());
            for(int i=0;i<n;i++){
                Object o1=list1.size()>i?list1.get(i):list1.getLast();
                Object o2=list2.size()>i?list2.get(i):list2.getLast();
                long range=timeStamp(o1,o2);
                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;
                }
                if(BigDecimal.ZERO.equals(b)){
                    result.add("");
                }else {
                    result.add(b.setScale(Integer.parseInt(scale.toString()), ROUND_HALF_UP));
                }
            }

        }
        return result;
    }
    public static long timeStamp(Object t1,Object t2){
        if(StringUtils.isNotEmpty(t1,t2)) {
            String s1 = t1.toString();
            String s2 = t2.toString();
            List<Integer> lsa1= Arrays.stream(s1.replaceAll("[\\s]+","").replaceAll("[\\D]+$","").split("[\\D]+")).map(Integer::parseInt).collect(Collectors.toList());
            List<Integer> lsa2= Arrays.stream(s2.replaceAll( "[\\s]+","").replaceAll("[\\D]+$", "").split("[\\D]+")).map(Integer::parseInt).collect(Collectors.toList());
            return list2Stamp(lsa2)-list2Stamp(lsa1);
        }
         return 0;
    }
    public static long list2Stamp(List<Integer>list){
        LocalDateTime localDateTime;
        if(list.size()>=5&&list.size()<=7){
             localDateTime=LocalDateTime.of(list.get(0),list.get(1),list.get(2),list.get(3),list.get(4),0,0);
        }else if(list.size()==3){
            localDateTime=LocalDateTime.of(list.get(0),list.get(1),list.get(2),0,0,0,0);
        }else if(list.size()==2){
            localDateTime=LocalDateTime.now().withHour(list.get(0)).withMinute(list.get(1)).withSecond(0).withNano(0);
        }else{
            localDateTime= LocalDateTime.now();
        }
      return localDateTime.atZone(ZoneOffset.UTC)
              .toInstant()
              .toEpochMilli();
    }



    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) {
        if(data.isEmpty()){
            data = data.stream()
                    .filter(Objects::nonNull)
                    .map(Object::toString)
                    .map(String::trim)
                    .filter(s -> !s.isEmpty())
                    .flatMap(s -> {
                        // 检查包含的分隔符类型，按优先级处理
                        if (s.contains("、")) {
                            return Arrays.stream(s.split("、"));
                        } else if (s.contains(",")) {
                            return Arrays.stream(s.split(","));
                        } else if (s.contains("，")) {
                            return Arrays.stream(s.split("，"));
                        } else if (s.contains("/")) {
                            return Arrays.stream(s.split("/"));
                        } else if (s.contains(" ")) {
                            return Arrays.stream(s.split("\\s+"));
                        } else {
                            return Stream.of(s);
                        }
                    })
                    .map(String::trim)
                    .filter(s -> !s.isEmpty())
                    .collect(Collectors.toList());
        }
        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("/");
                AtomicInteger total = new AtomicInteger();
                AtomicInteger pass = new AtomicInteger();
                List<List<Object>> dl = dataSpaceSplit(data);
                if(dl.size()==designArr.length){
                    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.addAndGet(StringUtils.handleObj2Integer(obs[0]));
                        pass.addAndGet(StringUtils.handleObj2Integer(obs[1]));
                    }
                }else{
                    List<Object> designList=Arrays.asList(designArr);
                    /*依次计算偏差挑选最佳设计值，并根据设计值分组，然后在计算是否合格*/
                    Function<Object,Object> fc=d-> designList.stream().reduce(Double.MAX_VALUE, (p, n) -> offRangeSum(CustomFunction.dXd(p, d,1,3)) < offRangeSum(CustomFunction.dXd(n, d,1,3)) ? p : n);
                    Map<Integer,List<Object>> group=data.stream().filter(StringUtils::isNotEmpty).collect(Collectors.groupingBy(x->designList.indexOf(fc.apply(x))));
                    Object finalXN = xN;
                    group.forEach((k, v)->{
                        Object[] obs = ck(v, designArr[k], devArr.length > k ? devArr[k] : devArr[devArr.length - 1], finalXN);
                        total.addAndGet(StringUtils.handleObj2Integer(obs[0]));
                        pass.addAndGet(StringUtils.handleObj2Integer(obs[1]));
                    });
                }
                if (total.get() > 0) {
                    result.add(total);
                    result.add(pass);
                    result.add(total.get() - pass.get());
                }
            } 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 void main(String[] args) {
        List<Object> list = Arrays.asList(29,30);
        b445check(list,"0","-30,30",1).forEach(System.out::println);
    }*/



    public static Object designFormat(Object design){
        if(StringUtils.isNotEmpty(design)){
            if(design instanceof List){
                List<Object> list = (List<Object>) design;
                StringBuffer str = new StringBuffer();
                for(Object o : list){
                    if(o == null){
                        continue;
                    }
                    if(o.toString().contains("*")){
                        str.append(o).append("/");
                    }else{
                        String collect = Arrays.stream(o.toString().split("[^\\d.-]")).filter(StringUtils::isNotEmpty).collect(Collectors.joining("/"));
                        if(StringUtils.isNotEmpty(collect)){
                            str.append(collect).append("/");
                        }
                    }
                }
                return str;
            }else{
                return  Arrays.stream(design.toString().split("[^\\d.\\-*]")).filter(StringUtils::isNotEmpty).collect(Collectors.joining("/"));
            }
        }
        return "";
    }

    public static double offRangeSum(Object o){
        if(o.equals(Double.MAX_VALUE)){
            return Double.MAX_VALUE;
        }
        return Arrays.stream(o.toString().split("[^0-9.\\-]")).mapToDouble(e->Math.pow(Double.parseDouble(e),2)).sum();
    }


    public static List<List<Object>> dataSpaceSplit(List<Object> data) {
        List<List<Object>> result = new ArrayList<>();
        if (ListUtils.isNotEmpty(data)) {
            List<Double> list= data.stream().filter(StringUtils::isNumber).map(x->Double.parseDouble(x.toString())).collect(Collectors.toList());
            List<List<Double>> target=segmentList(list);
            result=target.stream().map(l->l.stream().collect(Collectors.toCollection((Supplier<ArrayList<Object>>) ArrayList::new))).collect(Collectors.toList());
        }
        return result;
    }
    static List<List<Double>> segmentList(List<Double> inputList) {
        List<List<Double>> segments = new ArrayList<>();
        List<Double> currentSegment = new ArrayList<>();
        inputList.forEach(number -> {
            if (currentSegment.isEmpty() || shouldSplit(currentSegment, number)) {
                if (!currentSegment.isEmpty()) {
                    segments.add(new ArrayList<>(currentSegment));
                }
                currentSegment.clear();
            }
            currentSegment.add(number);
        });

        if (!currentSegment.isEmpty()) {
            segments.add(new ArrayList<>(currentSegment));
        }

        return segments;
    }

    static boolean shouldSplit(List<Double> segment, double number) {
        if (segment.isEmpty()) {
            return false;
        }
        double lastNumber = segment.get(segment.size() - 1);
        double difference = Math.abs((number - lastNumber) / lastNumber);
        return difference > 0.2 || difference > ((double) 50 / 100.0);
    }


    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.getScaleZero(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;
    }

/*    public static void main(String[] args) {
        List<Object> list = Arrays.asList("-9*5","2*3");
        checkpoints(list,"",0,"±5",1);
    }*/

    /**
     * @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)&&RegexUtil.match(ParamElements.LEVEL_REG, param.trim())) {
            List<String> nodes = new ArrayList<>(treeNodes);
            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).sorted().collect(Collectors.toList());
            Integer type = RandomNumberHolder.getRandomTemplateType();
            if(type==null||type==1){
                for (Integer i : index) {
                    if (i >= nodes.size()) {
                        continue;
                    }
                    boolean isExist = false;
                    //获取当前节点的名称
                    String title = nodes.get(i);
                    //当前节点的名称是否已经在父级节点中包含了
                    if(org.apache.commons.lang.StringUtils.isNotEmpty(title)){
                        for (int j = 0; j < i; j++) {
                            String parentTitle = nodes.get(j);
                            //如果父级节点名称中保存当前节点名称  就跳过当前节点
                            if(org.apache.commons.lang.StringUtils.isNotEmpty(parentTitle) && org.apache.commons.lang.StringUtils.isNotEmpty(title) && parentTitle.contains(title)){
                                isExist = true;
                                break;
                            }
                        }
                        if(isExist){
                            continue;
                        }
                        //保留之间的添加逻辑 在之前对数据做去重过滤
                        if (i < nodes.size()) {
                            result.add(nodes.get(i));
                        }
                    }
                }
                return String.join("", result);
            }else {
                List<WbsTreeContract> nodess = RandomNumberHolder.getRandomWbsTreeContract();
                Map<Integer, String> map = nodess.stream()
                    .collect(Collectors.toMap(
                        WbsTreeContract::getNodeType,
                        WbsTreeContract::getNodeName,
                        (existing, replacement) -> replacement // 如果键重复，保留后者
                    ));
                for (Integer i : index) {
                    boolean isExist = false;
                    //获取当前节点的名称
                    String title = map.get(i == 0 ? 1 : i == 1 && map.containsKey(18) ? 18 : i);
                    //当前节点的名称是否已经在父级节点中包含了
                    if(org.apache.commons.lang.StringUtils.isNotEmpty(title)){
                        for (int j = 0; j < i; j++) {
                            String parentTitle = map.get(j == 0 ? 1 : j == 1 && map.containsKey(18) ? 18 : j);
                            //如果父级节点名称中保存当前节点名称  就跳过当前节点
                            if(org.apache.commons.lang.StringUtils.isNotEmpty(parentTitle) && org.apache.commons.lang.StringUtils.isNotEmpty(title) && parentTitle.contains(title)){
                                isExist = true;
                                break;
                            }
                        }
                        if(isExist){
                            continue;
                        }
                        result.add(title);
                    }
                }
                return String.join("", result);
            }

        }
        return param;
    }

    public static Object tableNames(List<String> treeNodes) {
        if (CollectionUtil.isNotEmpty(treeNodes)) {
            List<String> nodes = new ArrayList<>(treeNodes);
            return nodes.stream().filter(StringUtils::isNotEmpty).map(e -> e.replaceAll("[\\s]+|_(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(item -> new BigDecimal(item).setScale(8, RoundingMode.HALF_UP).doubleValue()).noneMatch(e -> e > finalMax || e < finalMin)) {
                        result.add(obj);
                    }
                }
            }
        }
        List<Object> l2 = datas.stream().filter(StringUtils::isNumber).map(StringUtils::handleNull).map(item -> new BigDecimal(item).setScale(8, RoundingMode.HALF_UP).doubleValue()).filter(e -> e <= finalMax && e >= finalMin).collect(Collectors.toList());
        if (ListUtils.isNotEmpty(l2)) {
            result.addAll(l2);
        }
        return result;
    }

/*    public static void main(String[] args) {
        Double[] a = scopeParse("≤5",0,1);
        Double[] b = scopeParse("≦5",0,1);
        Double[] c = scopeParse("≤5",0,1);

        System.out.println(a);
    }*/


    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.contains("≦")) {
                devStr = devStr.replace("≤", "").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;
            }
            if(min>max){
                double tmp=max;
                max=min;
                min=tmp;
            }
            result[0] = min;
            result[1] = max;
            return result;
        }
        return null;
    }

    /**
     * @return java.util.List<java.lang.Object> 不能包含0
     * @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();
            int loop=200;
            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(tb.compareTo(BigDecimal.ZERO)==0&&loop>0){
                    loop--;
                    i--;
                }else{
                    if (scaleI > 0) {
                        result.add(tb.doubleValue());
                    } else {
                        result.add(tb.intValue());
                    }
                }
            }
            int total = StringUtils.handleObj2Integer(hz);
            if (total - hzi > 0) {
                loop=200;
                for (int k = 0; k < total - hzi; k++) {
                    BigDecimal tb;
                    /*保证salt是大于等于1的正整数*/
                    int salt=Math.max(1,(max - min) / 2);
                    if (rd.nextBoolean()) {
                        /*tb = new BigDecimal(rd.nextInt(((max - min) / 2)) + max + 1).divide(BigDecimal.valueOf(Math.pow(10, scaleI)), scaleI, ROUND_HALF_UP);*/
                        tb = new BigDecimal(rd.nextInt(salt) + 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);*/
                        tb = new BigDecimal(min - 1 - rd.nextInt(salt)).divide(BigDecimal.valueOf(Math.pow(10, scaleI)), scaleI, ROUND_HALF_UP);
                    }
                    if(tb.compareTo(BigDecimal.ZERO)==0&&loop>0){
                        loop--;
                        k--;
                    }else {
                        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;
    }
    public static List<Object> obj3List(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);
            }
            return datas;
        }
        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());
    }
    //obj转数组，不做任何额外的处理
    public static List<Object> obj3ListNe(Object obj) {
        List<Object> list = obj3List(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 {
                if(result.get(0).equals("-")){
                    String pattern = "^-?\\d+(\\.\\d+)?([+\\-*/]-?\\d+(\\.\\d+)?)*$";
                    Pattern r = Pattern.compile(pattern);
                    Matcher mm = r.matcher(String.valueOf(value));
                    boolean b = mm.matches();
                    if(b){
                        return result.get(1);
                    }
                }
                return result.get(0);
            }
        }
        return null;
    }

/*   public static void main(String[] args) {
        System.out.println(xN(0.0,0.0001));
    }*/
    /**
     * @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 : "");*/
                                d.append(BaseUtils.str2BigDecimal(s).scaleByPowerOfTen((int)Math.log10(xND)).stripTrailingZeros().toPlainString()).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)) {
                                cur = e.toString();
                               /* int scale = (int) Math.max(getScale(s) - Math.log10(xND), 0);
                                outList.add(StringUtils.number2String(Double.parseDouble(e.toString()) * xND, scale));*/
                                outList.add(BaseUtils.str2BigDecimal(e.toString()).scaleByPowerOfTen((int)Math.log10(xND)).stripTrailingZeros().toPlainString());
                            }
                        }
                    }
                    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) {
//         int x=1234567800;
//        System.out.println(xN(x,0.0001));
//    }

    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 follow(data);
    }

    /**元素内容永远跟随第一页*/
    public static List<Object> follow(List<Object> data) {
        if (data != null) {
            Object value = data.get(0);
            return Collections.nCopies(data.size(), value);
        }
        return new ArrayList<>();
    }

/*    public static void main(String[] args) {
        List<Object> l1 = Arrays.asList(1,2,3,4,5);
        List<Object> l2 = Arrays.asList("",2,3,4,5);
        follow(l1).forEach(System.out::println);
        follow(l2).forEach(System.out::println);
    }*/

    /**
     * @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... 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);
    }

/*
    public static void main(String[] args) {
        String a="100/200";
        List<Object>list  = new ArrayList<>(Arrays.asList(101,102,201,198));
        list.forEach(d-> System.out.println(dXd(a,d)));
    }
*/

    /**
     * @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./E]", design.toString(), 0, false));
            if (StringUtils.isEmpty(delimiter)) {
                delimiter = CONCAT;
            }
            String delimiter2 = handleNull(matcherFindGroup("[^0-9.E]", data.toString(), 0, false));
            if (StringUtils.isEmpty(delimiter2)) {
                delimiter2 = CONCAT;
            }
            String[] dArr = handleNull(design).split("[" + delimiter + "]");
            String[] bArr = handleNull(data).split("[" + delimiter2 + "]");
            Object _dx = null;
            for (int n = 0; n < dArr.length; n++) {
                String dsg=dArr[n];
                String xd=bArr[n];
                if(dsg.contains("/")){
                    String[] dsgA= dsg.split("/");
                    dsg= Arrays.stream(dsgA).filter(StringUtils::isNumber).min(Comparator.comparingDouble(e->Math.abs(StringUtils.obj2Double(calculate(xd,e,3,2))))).orElse(dsg);
                }
                BigDecimal a = new BigDecimal(dsg);
                BigDecimal b = new BigDecimal(xd);
                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, delimiter2);
                } 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) {
        if (data != null ) {
            List<Object> datas = obj2ListNe(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);
            return Math.sqrt(_datas.stream().mapToDouble(Double::parseDouble).map(e -> Math.pow(e - avgVal, 2)).sum() / total);
        }
        return "";
    }



    /*递进求和*/
    public static Object stepSum(List<Object> list){
            if(list!=null&&list.size()>0){
                 AtomicReference<Double> acc = new AtomicReference<>((double) 0);
                return list.stream().map(d-> StringUtils.isNumber(d)?acc.updateAndGet(s->s+Func.toDouble(d)):StringPool.EMPTY).collect(Collectors.toList());
            }
            return StringPool.EMPTY;
    }

/*
    public static void main(String[] args) {
        List<Object> list = Arrays.asList(0.83,0.82,0.91,0.89,0.97,0.98);
        ( (List<Object>)stepSum(list)).forEach(System.out::println);
    }
*/
     /*字符模版*/
      public static Object strTemplate(List<Object>data,String template){
          if(BaseUtils.isNotEmpty(template)) {
              return data.stream().map(s -> template.replaceAll("\\{\\s*}", BaseUtils.handleNull(s))).collect(Collectors.toList());
          }
          return data;
      }

    public static Object dateRange(List<Object>d1,List<Object>d2,String template){
        if(BaseUtils.isNotEmpty(template)&&BaseUtils.isNotEmpty(d1)&&BaseUtils.isNotEmpty(d2)) {
        return     IntStream.range(0,Math.min(d1.size(),d2.size())).boxed().map(i->{
                List<Object> list =new ArrayList<>();
                list.add(d1.get(i));
                list.add(d2.get(i));
                return list;
            }).map(l-> IntStream.range(0, l.size()).boxed().reduce(template, (str, i) -> str.replaceFirst("\\{}", l.get(i).toString()), String::concat)
             ).collect(Collectors.toList());
        }
        return template;
    }


/*    public static void main(String[] args) {
        List<Object> list = Arrays.asList("","20240403");
        List<Object> list2 = Arrays.asList("20040402","20240405");
        System.out.println(dateRange(list,list2,"时间范围{}至{}"));
    }*/

    /**转成人民币大写形式*/
      public static List<Object> toRmb(List<Object> arabic ){
          if(StringUtils.isNotEmpty(arabic)){
              return arabic.stream().filter(CustomFunction::isNumber).map(e -> StringUtils.obj2Double(e, 2)).filter(Objects::nonNull).map(org.springblade.business.utils.NumberUtil::numberToRMB).collect(Collectors.toList());
          }
          return arabic;
      }

/*
    public static void main(String[] args) {
        List<Object> list = Arrays.asList(68919641);
        toRmb(list).forEach(System.out::println);
    }

*/
    public static List<Object> toYear(List<Object> dateList){
        return toDate(dateList,0);
    }

    public static List<Object> toMonth(List<Object> dateList){
        return toDate(dateList,1);
    }

    public static List<Object> toDay(List<Object> dateList){
        return toDate(dateList,2);
    }

    public static List<Object> toDate(List<Object> dateList,int type){
        List<Object> result = new ArrayList<>();
        if(ListUtils.isNotEmpty(dateList)){
            for (Object o : dateList) {
                String d = StringUtils.handleNull(o);
                if (StringUtils.isNotEmpty(d)) {
                  /*  if (d.contains(",")) {
                        String[] arr = d.replaceAll("[\\[\\]\\s]+", "").split(",");
                        d = arr[arr.length - 1];
                    }*/
                    DateTime dt = new DateTime(d);
                    if(type==0) {
                        result.add(dt.year());
                    }else if(type==1) {
                        result.add(dt.month()+1);
                    }if(type==2) {
                        result.add(dt.dayOfMonth());
                    }
                }
            }
        }
        return result;
    }


/*    public static void main(String[] args) {
        List<Object> list = Arrays.asList("2024年07月2日","2024-07-2","2024.07.2");
        toYear(list).forEach(System.out::println);
        toMonth(list).forEach(System.out::println);
        toDay(list).forEach(System.out::println);
    }*/


    /**
     * 数据过滤提取
     * @param bias 偏差 字符串，例如：±10、＋10,-20；
     * @param designData 设置值，数组,
     * @param actualData 实测值，数组,
     * @param biasData 偏差值 数组,
     */
    public static Object dataFilterExtract(Object bias,Object biasTwo,Object designData,Object actualData,Object biasData){
        List<Object> obj1 = new ArrayList<>();
        List<Object> obj2 = new ArrayList<>();
        List<Object> obj3 = new ArrayList<>();
        //返回结果
        List<Object> result = new ArrayList<>();

        if (designData instanceof List) {
            obj1 = obj2List(designData);

        }
        if (actualData instanceof List) {
            obj2 = obj2List(actualData);
        }
        if (biasData instanceof List) {
            obj3 = obj2List(biasData);
        }
        //三种数据长度必须一致
        if(obj1.size() == obj2.size() && obj1.size() == obj3.size()){
            //满足设置值的索引
            Map<String, List<Integer>> stringListMap = StringUtils.deduplicateWithIndices(StringUtils.parseDeviationRange(bias, biasTwo),obj1,obj3);
            List<Object> finalObj = obj2;
            stringListMap.forEach((key, value) -> {
                //索引
                List<Integer> index = stringListMap.get(key);
                int sampleSize = index.size();
               //如果样本数量小于5，则获取全部数据
                if(index.size() > 1){
                    // 计算需要抽取的元素数量
                    sampleSize = (int) Math.ceil(index.size() * 0.3);
                }
                // 随机打乱列表
                Collections.shuffle(index);
                index.stream().limit(sampleSize).forEach(i ->{
                    result.add(finalObj.get(i));
                });
            });
        }else if (obj2.size() > 0 && obj1.size() == 0 && obj3.size() == 0){
            int sampleSize = obj2.size();
            //如果样本数量小于5，则获取全部数据
            if(obj2.size() > 1){
                // 计算需要抽取的元素数量
                sampleSize = (int) Math.ceil(obj2.size() * 0.3);
            }
            Collections.shuffle(obj2);
            List<Object> objects = obj2.subList(0, sampleSize);
            objects.stream().limit(sampleSize).forEach(result::add);
        }
        return result;
    }

    /**
     * 特征值计算
     */
    public static Object eigenvalue(Object data){

        //默认只有10组数据
        if (data != null ) {
            List<Object> datas = obj2ListNe(data);
            datas = datas.size() > 10 ? datas.subList(0, datas.size()/2) : datas;
            int total = datas.size();
            //换算系数
            double conversionFactor;
            //获取换算系数
            if(total >= 10 && total <= 15){
                conversionFactor = 1.695;
            }else if(total >= 16 && total <= 24){
                conversionFactor = 1.645;
            }else if(total>=25){
                conversionFactor = 1.595;
            }else{
                throw new ServiceException("数据组数小于10");
            }
            List<String> _datas = datas.stream().map(StringUtils::handleNull).collect(Collectors.toList());
            //获取平均值
            double avgVal = _datas.stream().mapToDouble(Double::parseDouble).average().orElse(0D);
            //获取标准差
            double sqrt = Math.sqrt(_datas.stream().mapToDouble(Double::parseDouble).map(e -> Math.pow(e - avgVal, 2)).sum() / (total-1));
            return avgVal - (conversionFactor * sqrt);
        }
        return null;
    }

    /**
     * 混凝土强度 “换算值”计算
     * @param data 混凝土强度实测值
     * @param angle 角度
     * @param pouringSurface 浇筑面
     * @param type 测区计算方式 1-单独测区深度，2-测区平均值
     * @param surveyDepth 测区深度
     * @param Pumping 是否泵送 1-是，2-否
     */
    public static Object concreteStrength(Object data, Object angle, Object pouringSurface, Object type, Object surveyDepth, Object Pumping) {
        List<Object> datas = obj2ListNe(data);
        List<Object> data1 = obj2ListNe(angle);
        List<Object> data2 = obj2ListNe(pouringSurface);
        List<Object> data4 = obj2ListNe(Pumping);

        //数据库查询对象
        JdbcTemplate jdbcTemplateStatic = SpringContextHolder.getBean(JdbcTemplate.class);

        if (CollectionUtil.isNotEmpty(datas) && CollectionUtil.isNotEmpty(data1) && CollectionUtil.isNotEmpty(data2) && surveyDepth != null && CollectionUtil.isNotEmpty(data4)) {
            angle = data1.get(0);
            pouringSurface = data2.get(0);
            Pumping = data4.get(0);

            List<Double> list = datas.stream().filter(StringUtils::isNumber).map(m -> Double.valueOf(m.toString())).collect(Collectors.toList());
            list = removeThreeMinAndMaxEfficient(list);
            //计算平均值
            BigDecimal asDouble = BigDecimal.valueOf(list.stream().filter(StringUtils::isNumber).map(StringUtils::handleNull).mapToDouble(Double::parseDouble).average().orElse(0.0));
            if (StringUtils.isNotEmpty(angle) && StringUtils.isNotEmpty(pouringSurface)) {
                //角度  根据平均值从数据库中查询对应的映射值
                List<Map<String, Object>> angleList = jdbcTemplateStatic.queryForList("select data_value from coordinate_angle where r_value = " + asDouble + " and h_value = " + angle);
                if (CollectionUtil.isNotEmpty(angleList)) {
                    Map<String, Object> stringObjectMap = angleList.get(0);
                    asDouble = asDouble.add(new BigDecimal(stringObjectMap.get("data_value").toString()));
                }
                //角度  根据平均值从数据库中查询对应的映射值
                List<Map<String, Object>> pouringSurfaceList = jdbcTemplateStatic.queryForList("select data_value from coordinate_pouring_urface where r_value = " + asDouble + " and h_value = '" + pouringSurface + "'");
                if (CollectionUtil.isNotEmpty(pouringSurfaceList)) {
                    Map<String, Object> stringObjectMap = pouringSurfaceList.get(0);
                    asDouble = asDouble.add(new BigDecimal(stringObjectMap.get("data_value").toString()));
                }

                //最终值 R H
                double r = asDouble.doubleValue();
                double h = 0;

                //测区深度 第一种只取第一条数据
                if (type == null || "1".equals(type.toString())) {
                    String surveyDepthStr;
                    if (surveyDepth instanceof List) {
                        List<Object> surveyDepthList = obj3ListNe(surveyDepth);
                        surveyDepthStr = surveyDepthList.get(0).toString();
                    } else {
                        surveyDepthStr = surveyDepth.toString();
                    }
                    //分割字符串
                    String[] split = surveyDepthStr.split(surveyDepthStr.contains(",") ? "," : "、");
                    //计算平均值
                    h = Arrays.stream(split).filter(StringUtils::isNumber).map(StringUtils::handleNull).map(BigDecimal::new).reduce(BigDecimal.ZERO, BigDecimal::add).divide(new BigDecimal(split.length), 10, RoundingMode.HALF_UP).doubleValue();
                    h = h * 2;
                    //进行0.5修正
                    h = roundHalfEven(new BigDecimal(h).setScale(1, RoundingMode.HALF_UP).doubleValue(), 1);
                    h = h / 2;
                } else {
                    List<Object> surveyDepthList = obj3ListNe(surveyDepth);
                    List<Double> doubleArrList = new ArrayList<>();
                    surveyDepthList.forEach(f -> {
                        String string = f.toString();
                        //分割字符串
                        String[] split = string.split(string.contains(",") ? "," : "、");
                        //计算平均值
                        double avg = Arrays.stream(split).filter(StringUtils::isNumber).map(BigDecimal::new).reduce(BigDecimal.ZERO, BigDecimal::add).divide(new BigDecimal(split.length), 10, RoundingMode.HALF_UP).doubleValue();
                        avg = avg * 2;
                        avg = roundHalfEven(new BigDecimal(avg).setScale(1, RoundingMode.HALF_UP).doubleValue(), 1);
                        avg = avg / 2;
                        doubleArrList.add(avg);
                    });
                    //结果再计算平均值
                    h = doubleArrList.stream().mapToDouble(Double::doubleValue).average().orElse(0.0);
                    h = h * 2;
                    //进行0.5修正
                    h = roundHalfEven(new BigDecimal(h).setScale(1, RoundingMode.HALF_UP).doubleValue(), 1);
                    h = h / 2;
                }

                //是否泵送
                if ("是".equals(Pumping) || "1".equals(Pumping)) {
                    //计算公式：f = 0.034488 * (R^1.9400) * 10^(-0.0173 * dm)
                    double v = 0.034488 * Math.pow(r, 1.9400) * Math.pow(10, -0.0173 * h);
                    return new BigDecimal(v).setScale(1, RoundingMode.HALF_UP);
                } else {
                    //从数据库中获取数据
                    List<Map<String, Object>> list1 = jdbcTemplateStatic.queryForList("select data_value from coordinate_data where r_value = " + r + " and h_value = " + h);
                    if (CollectionUtil.isNotEmpty(list1)) {
                        Map<String, Object> stringObjectMap = list1.get(0);
                        return new BigDecimal(stringObjectMap.get("data_value").toString()).setScale(1, RoundingMode.HALF_UP);
                    }
                }
            }
        }
        return null;
    }

    // 更高效的实现方式（一次性操作）
    public static List<Double> removeThreeMinAndMaxEfficient(List<Double> list) {
        if (list.size() <= 6) {
            return new ArrayList<>();
        }

        // 创建列表的副本
        List<Double> sortedList = new ArrayList<>(list);

        // 排序列表
        Collections.sort(sortedList);

        // 直接获取中间部分的元素（跳过前3个和后3个）
        return sortedList.subList(3, sortedList.size() - 3);
    }

    /**
     * 使用银行家舍入法进行0.5修正
     * @param number 要修正的数字
     * @param scale 保留的小数位数
     * @return 修正后的结果
     */
    public static double roundHalfEven(double number, int scale) {
        BigDecimal bd = BigDecimal.valueOf(number);

        // 获取小数部分
        BigDecimal integerPart = new BigDecimal(bd.toBigInteger().toString());
        BigDecimal decimalPart = bd.subtract(integerPart);

        // 如果小数部分为0，直接返回
        if (decimalPart.compareTo(BigDecimal.ZERO) == 0) {
            return number;
        }

        // 将小数部分乘以10，获取第一位小数
        BigDecimal firstDecimal = decimalPart.multiply(BigDecimal.TEN)
                .setScale(0, RoundingMode.DOWN);

        int firstDigit = firstDecimal.intValue();

        if (firstDigit < 5) {
            // 小数位数小于5，改成5
            return integerPart.add(new BigDecimal("0.5")).doubleValue();
        } else if (firstDigit > 5) {
            // 小数位数大于5，四舍五入到整数
            return bd.setScale(0, RoundingMode.HALF_UP).doubleValue();
        } else {
            // 等于5，不变
            return number;
        }
    }

    public static boolean isEven(BigDecimal number) {
        // 检查是否为整数
        if (number.scale() > 0 && number.stripTrailingZeros().scale() > 0) {
            throw new IllegalArgumentException("只能判断整数的奇偶性");
        }

        // 使用 remainder() 方法计算除以2的余数
        BigDecimal remainder = number.remainder(BigDecimal.valueOf(2));
        return remainder.compareTo(BigDecimal.ZERO) == 0;
    }

    /**
     * 字符串拆分计算
     * @param s
     * @param s1
     * @return
     */
    public static List<Integer> strSplitDiff(Object s,Object s1){
        List<Object> datas = obj3ListNe(s);
        List<Object> data1 = obj3ListNe(s1);
        return NumberStringSubtraction.calculateDifference(datas.get(0).toString(), data1.get(0).toString());
    }
}