bladex/blade-common/src/main/java/org/springblade/common/utils/BaseUtils.java

package org.springblade.common.utils;

import com.alibaba.cloud.commons.lang.StringUtils;
import org.checkerframework.checker.regex.RegexUtil;
import org.springblade.common.constant.RegexConstant;
import org.springblade.common.vo.DataVO;

import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.security.MessageDigest;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import static java.math.BigDecimal.*;

/**
 * @author yangyj
 * @Date 2022/7/8 11:08
 * @description 基础工具类
 */
public class BaseUtils {
    public  static DateTimeFormatter chineseDateFm = DateTimeFormatter.ofPattern("yyyy年M月d日", Locale.CHINA);

    public static Pattern KM = Pattern.compile(RegexConstant.KM_REG);

    public static double k2d(Object k) {
        Matcher mt = KM.matcher(k.toString());
        if (mt.find()) {
            return Double.parseDouble(mt.group(1)) * 1000 + Double.parseDouble(mt.group(2));
        }
        return -1;
    }

    public static  Double milestone(String s){
        Pattern pattern=Pattern.compile("(?i)K(\\d+)\\+([\\d.]+)");
        Matcher matcher = pattern.matcher(s);
        if(matcher.find()){
            return   Double.parseDouble(matcher.group(1))*1000+ Double.parseDouble(matcher.group(2));
        }
        return null;
    }


    /**
     * @return java.util.Map<java.lang.String, java.lang.String>
     * @Description 将key1(val1)key2(val2)key3(val3)...这种格式的参数转换为Map
     * @Param [str]
     * @Author yangyj
     * @Date 2022.08.12 10:39
     **/
    public static Map<String, String> string2Map(String str) {
        Map<String, String> result = new HashMap<>(15);
        if (StringUtils.isNotEmpty(str)) {
            String[] args = str.split("\\)");
            for (String a : args) {
                if (StringUtils.isNotEmpty(a)) {
                    String[] kv = a.split("\\(");
                    result.put(kv[0], kv[1]);
                }
            }
        }
        return result;
    }



    /**
     * @return java.lang.Boolean
     * @Description 基础数据类型批量非空判断
     * @Param [args]
     * @Author yangyj
     * @Date 2022.08.26 11:14
     **/
    public static Boolean isNotNull(Object... args) {
        if (args != null) {
            for (Object obj : args) {
                if (obj == null || "".equals(obj)) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
/*将不同长度的字符串转换为固定长度的Long*/
    public static long str2Long(String input) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] hash = md.digest(input.getBytes());
            BigInteger bigInt = new BigInteger(1, hash);

            // 取正整数
            return bigInt.longValue() & Long.MAX_VALUE;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**最小分割片*/
    public static int sliceNumber(Integer len,Integer capacity){
        return (int)Math.ceil(len/(double)capacity);
    }
    /**
     * @Description  判断对象是否为数值
     * @Param [value]
     * @Author yangyj
     * @Date 2023.01.17 13:48
     **/
    static final String NUM_REG = "^[+-]?\\d+(\\.\\d+)?$";
    public static boolean isNumber(Object value) {
        if ((value == null) ) {
            return false;
        }
        String stringValue = value.toString().trim();
        if (stringValue.isEmpty()) {
            return false;
        }
        if (value instanceof Number) {
            return true;
        }
      return Pattern.matches(NUM_REG,stringValue);
    }


    static final String ZERO_REG = "^(0(\\.0*)?|0[eE]-\\d+)$";
    public static boolean isZero(Object value) {
        if ((value == null) ) {
            return false;
        }
        String stringValue = value.toString().trim();
        if (stringValue.isEmpty()) {
            return false;
        }
        return Pattern.matches(ZERO_REG,stringValue);
    }



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


    public static BigDecimal str2BigDecimal(Object s){
        if(s instanceof  BigDecimal){
            return (BigDecimal) s;
        }
        if(isNumber(s)){
            return new BigDecimal(s.toString());
        }else{
            return ZERO;
        }
    }

    public static String bigDecimalScale(Object s,int scale){
             return str2BigDecimal(s).setScale(scale,RoundingMode.HALF_UP).stripTrailingZeros().toPlainString();
    }

    /*默认返回零*/
    public static Double obj2DoubleZero(Object obj) {
        if(obj instanceof  Double){
            return (Double) obj;
        }
       if(isNumber(obj)){
           if(obj instanceof Number){
               if(obj instanceof  BigDecimal){
                   return str2BigDecimal(obj).doubleValue();
               }
               return (double) obj;
           }
           return Double.parseDouble(obj.toString());
       }
       return 0D;
    }
    /*默认返回零*/
    public static Integer obj2IntegerZero(Object obj) {
        if(isNumber(obj)){
            if(obj instanceof Number){
                if(obj instanceof  BigDecimal){
                    return str2BigDecimal(obj).intValue();
                }
                return (int) obj;
            }
            return Integer.parseInt(obj.toString());
        }
        return 0;
    }

    /**
     * @Description  根据指定大小对LIST进行切分
     * @Param [list, chunkSize：每一段长度]
     * @return java.util.List<java.util.List<T>>
     * @Author yangyj
     * @Date 2023.07.03 13:46
     **/
    public static <T> List<List<T>> splitList(List<T> list, int chunkSize) {
        return IntStream.range(0, (list.size() + chunkSize - 1) / chunkSize)
                .mapToObj(i -> list.subList(i * chunkSize, Math.min((i + 1) * chunkSize, list.size())))
                .collect(Collectors.toList());
    }


    /**
     * @Description 深度拷贝
     * @Param [originalList]
     * @return java.util.List<T>
     * @Author yangyj
     * @Date 2023.04.28 14:18
     **/
    public static <T extends Serializable> List<T> copyList(List<T> originalList) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(originalList);
            oos.close();
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            @SuppressWarnings("unchecked")
            List<T> copiedList = (List<T>) ois.readObject();
            ois.close();
            return copiedList;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String handleNull(Object obj) {
        if (null == obj) {
            return "";
        } else {
            return obj.toString().trim();
        }
    }
    public static boolean isNotEmpty(Object value) {
             if(value!=null){
                 if(value instanceof List&&((List<?>) value).size()>0 ){
                    return true;
                 }else if(value instanceof Map&&((Map<?, ?>) value).size()>0){
                     return true;
                 }else {
                     return value.toString().trim().length() > 0;
                 }
             }
             return false;
    }

    public static boolean isEmpty(Object value){
        return !isNotEmpty(value);
    }

    public static List<Integer> coords2Int(String coords){
        Matcher mx = matcher("([A-Z]{1,3})(\\d{1,3})[~|\\-|,|#]([A-Z]{1,3})(\\d{1,3})",coords);
        List<Integer> list = new ArrayList<>();
        if(mx.find()) {
            list.add(Integer.parseInt(mx.group(1)));
            list.add(Integer.parseInt(mx.group(2)));
            list.add(Integer.parseInt(mx.group(3)));
            list.add(Integer.parseInt(mx.group(4)));
        }
        return list;
    }
    public static Matcher matcher(String regex, String value) {
        Pattern pattern = Pattern.compile(regex);
        return pattern.matcher(value);
    }

    public static Double[] scopeParse(Object dev, Object design, Object xN) {
        if (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;
    }

    public static Integer handleObj2Integer(Object obj) {
        if (null == obj) {
            return 0;
        } else {
            double value;
            try {
                value = Double.parseDouble(obj.toString());
            } catch (Exception ex) {
                value = 0;
            }
            return (int) value;
        }
    }


    /**
     * @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 (isNotNull(design, dev, hz)) {
            if (isEmpty(scale)) {
                scale = 0;
            }
            if (isEmpty(passRate)) {
                passRate = 1;
            }
            if (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 = handleObj2Integer(hz);
            if (total - hzi > 0) {
                loop=200;
                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(tb.compareTo(BigDecimal.ZERO)==0&&loop>0){
                        loop--;
                        k--;
                    }else {
                        if (scaleI > 0) {
                            result.add(tb.doubleValue());
                        } else {
                            result.add(tb.intValue());
                        }
                    }
                }
                if (result.size()>0) {
                    Collections.shuffle(result);
                }
            }
        }
        return result;
    }

    /*是否包含链*/
     public static boolean notInChain(List<String> cp,String s){
        if(cp!=null&& isNotEmpty(s)){
            if(cp.size()==0){
                /*空结合*/
                return true;
            }else{
                /*没有一个已知路径包含*/
                return cp.stream().noneMatch(c->c.contains(s));
            }

        }
        return false;
     }

    public static boolean inChain(List<String> cp,String s){
        if(cp!=null&& isNotEmpty(s)){
            if(cp.size()==0){
                /*空结合*/
                return true;
            }else{
                /*没有一个已知路径包含*/
                return cp.stream().anyMatch(s::contains);
            }

        }
        return false;
    }
    public static boolean inChain(String[] cp,String s){
        if(cp!=null&&cp.length>0&& s!=null&&s.length()>0){
            return inChain(Arrays.asList(cp), s);
        }
        return false;
    }
    public static Integer getScale(Object... number) {
        int max = 0;
        if (number != null) {
            return getScale(scaleParam(number),1);
        }
        return max;
    }
    /**保留有效数字后面的0*/
    public static Integer getScaleZero(Object... number){
        int max = 0;
        if (number != null) {
            return getScale(scaleParam(number),0);
        }
        return max;
    }

    public static boolean containsZH(Object chars) {
        Matcher m = Pattern.compile("[\u4e00-\u9fa5]").matcher(handleNull(chars));
        return m.find();
    }

/*    public static void main(String[] args) {
        System.out.println(getScaleZero(152000,"±10.0"));
        System.out.println(getScaleZero(152000,"-10.0,10"));
        System.out.println(getScaleZero(152000,"-10.0,10.0"));
        System.out.println(getScaleZero(Double.MAX_VALUE,"-10.0,10"));
        System.out.println(getScaleZero(152000,"-10,10"));
    }*/
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 (isNotEmpty(datas)) {
            for (Object e : datas) {
                boolean fi = isNotEmpty(e) && !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> obj2ListNe(Object obj) {
        List<Object> list = obj2List(obj);
        return list.parallelStream().filter(BaseUtils::isNotEmpty).collect(Collectors.toList());
    }
    public static List<Object> scaleParam(Object ... number){
        return Arrays.stream(number).filter(BaseUtils::isNotEmpty).flatMap(e-> BaseUtils.obj2ListNe(e).stream()).distinct().map(s->s.toString().replaceAll("±","")).filter(BaseUtils::isNumber).map(e->{
            /*0.3999999999999986 检测到超长小数位先转double处理,再还原回String*/
            String tg=e.toString();
            int dot=tg.indexOf(".");
            boolean unlimited=dot>0&&(tg.length()-dot>6);
            if(unlimited||tg.contains("e")){
                return BigDecimal.valueOf(Double.parseDouble(tg)).setScale(2, RoundingMode.HALF_UP).toString();
            }else {
                return e;
            }
        }).collect(Collectors.toList());
    }

    public static final String[] SCALE_REG=new String[]{"(\\d)+.(\\d)*[0-9]","(\\d)+.(\\d)*[1-9]"};
    private static Integer getScale(List<Object> number,Integer zero){
        int max=0;
        if(isNotEmpty(number)){
            for (Object n : number) {
                if (isNotEmpty(n)) {
                    String[] sa = n.toString().split(",");
                    for (String s : sa) {
                        Matcher m = Pattern.compile(SCALE_REG[zero]).matcher(s);
                        if (m.find()) {
                            int cp = new StringBuilder(m.group()).reverse().toString().indexOf(".");
                            if (cp < 5) {
                                max = Math.max(cp, max);
                            }
                        }
                    }
                }
            }
        }
        return max;
    }
    private static final String COLUMN_REG = "^[A-Z]{0,2}$";
    /*列名转int*/
    public static int parseColumn(String column) {
        int value = -1;
        if (StringUtils.isNotEmpty(column)) {
            column = column.trim();
            if (column.matches(COLUMN_REG)) {
                char[] columnCh = column.toCharArray();
                for (char ch : columnCh) {
                    //字母, 最长只考虑双字母的
                    if (ch >= 65 && ch <= 90) {
                        if (value > 0) {
                            value = (26 * value) + (ch - 64);
                        } else {
                            value = ch - 64;
                        }
                    }
                }
            }
        }
        return value - 1;
    }

   public static  String toDateStr(LocalDate date){
        return Optional.ofNullable(date).orElse(LocalDate.now()).format(chineseDateFm);
   }

    public  static long  getTimeMs(int periodYear,int periodMonth ){
        LocalDateTime localDateTime = LocalDateTime.of(periodYear, periodMonth, 1, 0, 0, 0);
        ZoneId zoneId = ZoneId.systemDefault(); // 使用系统默认时区
        ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);
        return zonedDateTime.toInstant().toEpochMilli();
    }

    public static LocalDateTime toLdt(long millis) {
        Instant instant = Instant.ofEpochMilli(millis);
        ZonedDateTime zonedDateTime = instant.atZone(ZoneId.systemDefault());
        return zonedDateTime.toLocalDateTime();
    }

    public static int dateInt(int periodYear,int periodMonth){
        return   periodYear*100+periodMonth;
    }



    public static List<Integer> getTickUnit(int min, int max){
        int a1 = min / 100; // 得到最小年份
        int a2 = max / 100; // 得到最大年份
        int b1 = min % 100; // 得到最小月份
        int b2 = max % 100; // 得到最大月份
        // 确保月份在 1 到 12 之间
        if (b1 == 0) { b1 = 1; a1--; }
        if (b2 == 0) { b2 = 12; a2--; }
        int finalA = a1;
        int finalB = b1;
        int finalA1 = a2;
        int finalB1 = b2;
        return IntStream.rangeClosed(a1, a2)
                .boxed()
                .flatMap(year -> {
                    int startMonth = (year == finalA) ? finalB : 1;
                    int endMonth = (year == finalA1) ? finalB1 : 12;
                    return IntStream.rangeClosed(startMonth, endMonth)
                            .boxed()
                            .map(month -> dateInt(year, month));
                })
                .collect(Collectors.toList());
    }

}