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.jsoup.Jsoup;
import org.springblade.core.tool.utils.*;
import java.io.FileInputStream;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import static java.math.BigDecimal.ROUND_CEILING;
import static java.math.BigDecimal.ROUND_HALF_UP;


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


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





	/**
	 * @Description  根据桩号类型生成桩号
	 * @Param [stationType]
	 * @return java.lang.String
	 * @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 "";
	}


	/**
	 * @Description 记录表5输入桩号代码解析，2G1#1+100>>2G1K0+100
	 * @Param [stake]
	 * @return java.lang.String[] result[0]：返回桩号前缀;result[1]:实际显示前缀;result[2]:里程数
	 * @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;
	}
	/**
	 * @Description 获取最大小数位
	 * @Param [number]
	 * @return int
	 * @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 "";
	}

	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.handleNull(e).contains(":"))){
				return list.stream().filter(StringUtils::isNotEmpty).count();
			}
			return   list.stream().filter(StringUtils::isNumber).map(StringUtils::handleNull).mapToDouble(Double::parseDouble).count();
		}
		return "";
	}




	/**
	 * @Description  输出勾选复选框
	 * @Param [o1, o2]
	 * @return java.lang.Object
	 * @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 "";
	}
	/**
	 * @Description 返回n个空格，用于输出字符串格式化
	 * @Param [n]
	 * @return java.lang.Object
	 * @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 "";
	}





	/**
	 * @Description 字符串中是包含中文
	 * @Param [chars]
	 * @return boolean
	 * @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();
   }

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


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









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


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

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

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


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


    public static  Object goodSize(List<Object> data ,String cp){
        if(Func.isNotEmpty(data)&&Func.isNotBlank(cp)){
            data=data.stream().filter(Func::isNotEmpty).map(e->e.toString().replaceAll("\\s+","")).collect(Collectors.toList());
            return data.stream().filter(e->StringUtils.isEquals(e,cp)).count();
        }
        return "";
    }
	/**
	 * @Description 阶梯合格率
	 * @Param [data]
	 * @return java.lang.Object
	 * @Author yangyj
	 * @Date 2022.12.21 11:59
	 **/
	public static  Object ladder(List<Object> data){
	     if(Func.isNotEmpty(data)){
	       OptionalDouble op=data.stream().map(StringUtils::handleNull).filter(StringUtils::isNumber).mapToDouble(Double::parseDouble).min();
	       if(op.isPresent()){
	       	   return op.getAsDouble()>=90?90:70;
		   }
		 }
		return "";
	}

	/**
	 * @Description 主要工序质量等级
	 * @Param [data]
	 * @return java.lang.Object
	 * @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 "";
	}
    /**
     * @Description 单元工程质量等级评定
     * @Param [rate, level]
     * @return java.lang.Object
     * @Author yangyj
     * @Date 2022.12.21 14:33
     **/
    public static  Object unit(Object rate ,Object level){

         if(StringUtils.isNotEmpty(rate,level)){
             return StringUtils.obj2Double(rate.toString())>50&&"优良".equals(level.toString())?"优良":"合格";
         }
        return "";
    }
    /**
     * @Description 主控项目数量
     * @Param [data]
     * @return java.lang.Object
     * @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 "";
    }



    /**
	 * @Description 时间比较获取
	 * @Param [list：时间集合, comparator 比较器 ]
	 * @return cn.hutool.core.date.DateTime
	 * @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("_+\\d+","")).distinct().collect(Collectors.joining(StringPool.NEWLINE));
		}
		return StringPool.EMPTY;
	};

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


	/**
	 * @Description 计算t1~t2,t3~t4 两个时间段的合计时间，unit 输入数值的单位
	 * @Param [t1, t2, t3, t4, unit]
	 * @return java.lang.Object
	 * @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  "";
	}
	/**
	 * @Description 字符串日期转指定格式日期
	 * @Param [date, format：输出格式]
	 * @return java.lang.Object
	 * @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 "";
	}



	/**
	 * @Description 求偏差值
	 * @Param [list, design]
	 * @return java.lang.Object
	 * @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 "";
	}



	/**
	 * @Description 把日期格式化成 'xxxx年xx月xx日 星期x' 字符串
	 * @Param [date]
	 * @return java.lang.Object
	 * @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;
	}


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

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

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

	public static  Object daysPassed(Object t1,Object t2){
		return timePassed(t1,t2,"D",0,"yyyy-MM-dd");
	}
	public static  Object hoursPassed(Object t1,Object t2){
    	return timePassed(t1,t2,"H",0,"yyyy-MM-dd HH");
	}
	public static  Object minutesPassed(Object t1,Object t2){
		return timePassed(t1,t2,"m",0,"yyyy-MM-dd HH:mm");
	}
	/**
	 * @Description 输入时间格式：mm:ss(例如01:33)
	 * @Param [t1, t2]
	 * @return java.lang.Object
	 * @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();
		}
	}

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



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

	/**
	 * @Description   开方
	 * @Param [a：被开方数, scale：结果的小数位]
	 * @return java.lang.Object
	 * @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 "";
	}



	/**
	 * @Description   平方
	 * @Param [a：开方数, scale：结果的小数位]
	 * @return java.lang.Object
	 * @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 "";
	}




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










	/**
	 * @Description 生成用户指定范围实测值
	 * @Param [n 数量, design 设计值, scope 偏差范围, rate 合格率0~1, scale保留小数位]
	 * @return java.util.List<java.lang.Object>
	 * @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;
	}




	/**
	 * @Description 累加器
	 * @Param [scale：保留小数位, args：累加对象,支持动态数量]
	 * @return java.lang.Object
	 * @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 "";
	}








	/**
	 * @Description  空白或者/都判断为空
	 * @Param [data]
	 * @return java.lang.Object
	 * @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);
	}
	/**
	 * @Description   河南项目检查结果
	 * @Param [data, designs, dev, xN, hz]
	 * @return [共检数量,合格数量,不合格数量...]
	 * @Author yangyj
	 * @Date 2022.08.01 11:06
	 **/
	public static List<Object>  b445check(List<Object> data,Object designs,Object dev,Object xN,Object hz){

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

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



	public static final String ELE_CODE_REG= "(?<=E\\[)[^]]+(?=\\])";
	public static final  Pattern P = Pattern.compile(ELE_CODE_REG);
	public static List<String> parseElementCode(String s){
		   List<String> result =new ArrayList<>();
		   Matcher m= P.matcher(s);
		   while (m.find()){
		   	 result.add(m.group().replace("'",""));
		   }
		   return result;
	}

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

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

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

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

	public static Object tree(List<String>treeNodes,String param){
		if(CollectionUtil.isNotEmpty(treeNodes)&& Func.isNotBlank(param)){
			List<String>nodes=new ArrayList<>(treeNodes);
			//Collections.reverse(nodes);
			List<String> result = new ArrayList<>();
			param=param.trim().replaceAll("(?i:c)","");
			List<String> list = Arrays.asList(param.split("[^.\\d]"));
			List<Integer> index =list.stream().map(Integer::parseInt).collect(Collectors.toList());
			for(Integer i:index){
				if(i<nodes.size()) {
					result.add(nodes.get(i));
				}
			}
			return String.join("", result);
		}
        return "";
	}
	public static Object tableNames(List<String>treeNodes){
		if(CollectionUtil.isNotEmpty(treeNodes)){
			List<String>nodes=new ArrayList<>(treeNodes);
           return   nodes.stream().filter(e->StringUtils.isNotEmpty(e)&&!e.contains("A15")).map(e->e.replaceAll("__\\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);
	}
	/**
	 * @Description Qualified rate of measured value 计算合格率
	 * @Param [design： 设计值, dev：偏差范围或规定值, xN：偏差值单位转设计值单位倍率, data：数据, scale：保留小数位]
	 * @return java.lang.Object
	 * @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 "";
	}

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


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

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

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

	/**
	 * @Description obj 转List
	 * @Param [obj]
	 * @return java.util.List<java.lang.Object>
	 * @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){
					if(StringUtils.isNotEmpty(e)&&!CustomFunction.containsZH(e.toString())&&(e.toString().contains("、")||e.toString().contains(",")||e.toString().contains(" ")||e.toString().contains("，"))){
						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;
	}

	/**
	 * @Description 对象转字符串，list取第一个对象
	 * @Param [obj]
	 * @return java.lang.Object
	 * @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 "";
	}

	/**
	 * @Description 三元运算 bool?o1:o2 ,默认返回空字符串
	 * @Param [bool, o1, o2]
	 * @return java.lang.Object
	 * @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);
	}
	/**
	 * @Description  判断o1中是否包含字符串o2
	 * @Param [o1, o2]
	 * @return java.lang.Object
	 * @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;
	}
	/**
	 * @Description 判断两个对象是否相等
	 * @Param [o1, o2]
	 * @return java.lang.Object
	 * @Author yangyj
	 * @Date 2021.08.23 16:51
	 **/
	public static Object eq(Object o1 ,Object o2){
		return  StringUtils.isEquals(o1,o2);
	}




	/**
	 * @Description 计算数据集的合格率
	 * @Param [list：数据集, design：设计值, dev：偏差范围, scale：保存小数位]
	 * @return java.lang.Object
	 * @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 "";
	}



	/**
	 * @Description 获取最后一个对象
	 * @Param [list]
	 * @return java.lang.Object
	 * @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 "";
	}


	 public static Map<String, String> getElementCell(String uri) {
		try {
			return  Jsoup.parse(IoUtil.readToString(new FileInputStream(ResourceUtil.getFile(uri))))
					.select("table").first()
					.select("tr").stream()
					.flatMap(tr->tr.select("td").stream())
					.filter(d->!d.children().isEmpty())
					.map(d->d.children().get(0)).map(d->d.attr("keyname")).filter(StringUtils::isNotEmpty).map(e->e.split("__"))
					.reduce(
							new HashMap<>(),
							(a,b)->{
								a.merge(b[0], b[1], (v1, v2) -> v1 + ";" + v2);
								return  a;},
							(a,b)->null
					);
		}catch (Exception e){
			e.printStackTrace();
			return new HashMap<>();
		}
	}



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

	}

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


	/**
	 * @Description 过滤掉List中的空对象
	 * @Param [o]
	 * @return java.lang.Object
	 * @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;
	}

	/**
	 * @Description 设置保留小数位
	 * @Param
	 * @return
	 * @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;
	}

	/**
	 * @Description 返回正则式匹配内容
	 * @Param [regex：正则式, value：匹配的字符串, i：group(i), g:是否返回全局搜索，全局搜索返回的是列表]
	 * @return java.lang.Object
	 * @Author yangyj
	 * @Date 2021.01.08 16:31
	 **/
	public static Object matcherFindGroup(String regex, String value ,int i,boolean g){
		Matcher m = RegexUtils.matcher(regex,value);
		List<Object> result = new ArrayList<>();
		while (m.find()){
			result.add(m.group(i));
		}
		if(ListUtils.isNotEmpty(result)){
			if(g){
				return result;
			}else {
				return result.get(0);
			}
		}
		return null;
	}
	/**
	 * @Description 放大缩小
	 * @return java.lang.Object
	 * @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 = (List<Object>)o;
					for(Object e:datas){
						if(StringUtils.isNotEmpty(e)){
							String[] as = e.toString().split("[^\\d.]");
							Object m= matcherFindGroup("[^\\d.]",e.toString(),0,false);
							StringBuilder d = new StringBuilder();
							for(int i=0;i<as.length;i++){
								String s=as[i];
								cur=s;
								int scale = (int) Math.max(getScale(s)-Math.log10(xND),0);
                                d.append(StringUtils.number2String(Double.parseDouble(s) * xND, scale)).append(i!=as.length-1&&m!=null?m:"");
							}
							outList.add(d.toString());
						}
					}
					if(ListUtils.isNotEmpty(outList)){
						return outList;
					}
				}else{
					List<Object> datas = Arrays.asList(o.toString().split("[、， ,]"));
					Matcher m = RegexUtils.matcher("[、， ,]",o.toString());
					String s="、";
					if(m.find()){
						s=handleNull(m.group());
					}
					if(ListUtils.isNotEmpty(datas)){
						for(Object e:datas){
							if(StringUtils.isNotEmpty(e)){
								int scale = (int) Math.max(getScale(s)-Math.log10(xND),0);
								cur=e.toString();
								outList.add(StringUtils.number2String(Double.parseDouble(e.toString())*xND,scale));
							}
						}
					}
					if(ListUtils.isNotEmpty(outList)){
						return StringUtils.join(outList.stream().map(StringUtils::handleNull).collect(Collectors.toList()),s);
					}
				}
			}
		}catch (NumberFormatException e){
			e.printStackTrace();
			String  error = "";
			if(e.getMessage().contains("multiple points")){
				error=cur+"包含多个小数点";
			}else {
				error=cur;
			}
			return "NumberFormatException(数字格式异常，请检查)"+error;
		}
		return "";
	}

	public static  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+、","")).distinct().map(e->(index.getAndIncrement())+"、"+e+"\n").collect(Collectors.toList());
			}else{
				result=list.stream().distinct().collect(Collectors.toList());
			}
		}
		return  result;
	}
	/**
	 * @Description  截取list subList(list,1,5) 返回list的第1到第5个元素
	 * @Param [o]
	 * @return java.lang.Object
	 * @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;
	}

	/**
	 * @Description 获取G8测点偏差
	 * @Param [cd, pc]
	 * @return java.lang.Object
	 * @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;
	}



	/**
	 * @Description  list 去头尾
	 * @Param [o]
	 * @return java.lang.Object
	 * @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;
	}

	/**
	 * @Description 获取动态行某列内容
	 * @Param [data, field]
	 * @return java.lang.Object
	 * @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;
	}

	/**
	 * @Description 合并多个list
	 * @Param [listArr]
	 * @return java.lang.Object
	 * @Author yangyj
	 * @Date 2021.12.31 15:10
	 **/
	public static  Object mergeList(Object l1,Object l2){
		return _mergeList(l1,l2);
	}
	public static  Object mergeList(Object l1,Object l2,Object l3){
		return _mergeList(l1,l2,l3);
	}
	public static  Object mergeList(Object l1,Object l2,Object l3,Object l4){
		return _mergeList(l1,l2,l3,l4);
	}
	public static  Object mergeList(Object l1,Object l2,Object l3,Object l4,Object l5){
		return _mergeList(l1,l2,l3,l4,l5);
	}
	public static  Object mergeList(Object l1,Object l2,Object l3,Object l4,Object l5,Object l6){
		return _mergeList(l1,l2,l3,l4,l5,l6);
	}
	public static  Object mergeList(Object l1,Object l2,Object l3,Object l4,Object l5,Object l6,Object l7){
		return _mergeList(l1,l2,l3,l4,l5,l6,l7);
	}
	public static  Object mergeList(Object l1,Object l2,Object l3,Object l4,Object l5,Object l6,Object l7,Object l8){
		return _mergeList(l1,l2,l3,l4,l5,l6,l7,l8);
	}
	public static  Object _mergeList(Object ...listArr){
		List<Object> result = new ArrayList<>();
	    if(listArr!=null&&listArr.length>=2){
	    	List<List<Object>> tmp =new ArrayList<>();
	    	int max=0;
	    	for(Object o:listArr){
				List<Object> list = Collections.singletonList("");
	    		if(o instanceof List){
	    			list = (List<Object>) o;
					max=Math.max(max,list.size());
				}
	    		tmp.add(list);
			}
	    	if(ListUtils.isNotEmpty(tmp)){
	    		for(int i=0;i<max;i++){
	    			for(List<Object> _l:tmp){
	    				if(_l.size()>i){
	    					result.add(_l.get(i));
						}else{
	    					result.add("");
						}
					}
				}
			}
		}
		return result;
	}

	/**
	 * @Description 删除列表最后一个数据
	 * @Param [o]
	 * @return java.lang.Object
	 * @Author yangyj
	 * @Date 2021.07.28 15:47
	 **/
	public static  Object remLast(Object o){
		if(o instanceof  List){
		     rem(o,	((List<Object>)o).size()-1);
		}
		return  o;
	}
	/**
	 * @Description list 转 string
	 * @Param [o, separator:分隔符]
	 * @return java.lang.Object
	 * @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 "";
	}





	/**
	 * @Description String 转List
	 * @Param [o, separator]
	 * @return java.lang.Object
	 * @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]
	 * @return void
	 * @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());
		}
	}

	/**
	 * @Description  根据百分比返回子集list内容
	 * @Param [obj：数据源, percent：0-100]
	 * @return java.lang.Object
	 * @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 "";
	}






	public static boolean isNumeric(String str){
		Pattern pattern = Pattern.compile("[0-9.]*");
		return pattern.matcher(str).matches();
	}



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







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



}