常用工具类

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.duofriend.plugin.sdk.entity.open.condition.WxOpenMpApiCondition;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.rowset.serial.SerialBlob;
import javax.sql.rowset.serial.SerialException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.sql.Blob;
import java.sql.SQLException;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


@Slf4j
public class CommonUtil {

    private static final String ISO8859_1 = "iso8859-1";

    private CommonUtil() {
    }

    /**
     * 判断对象是否为空
     */
    public static boolean isEmpty(Object obj) {
        boolean b = false;
        try {
            if (obj == null || "".equals(obj) || "null".equals(obj) || " ".equals(obj)) {
                b = true;
            } else {
                b = false;
            }
        } catch (Exception e) {
            b = false;
            log.error("", e);
        }
        return b;
    }

    /**
     * 判断对象是否不为空
     */
    public static boolean isNotEmpty(Object obj) {
        boolean b = false;
        try {
            if (obj == null || "".equals(obj) || "null".equals(obj)) {
                b = false;
            } else {
                b = true;
            }
        } catch (Exception e) {
            b = false;
            log.error("判断对象是否不为空异常：{}", e);
        }
        return b;
    }

    /**
     * 转Integer
     */
    public static Integer toInteger(Object obj) {
        try {
            if (!isEmpty(obj)) {
                return Integer.parseInt(obj.toString());
            } else {
                log.error("对象为空，转换Integer失败！");
            }
        } catch (Exception e) {
            log.error("转Integer失败：{}", e);
        }
        return null;
    }

    public static Integer toIntegerByDouble(double obj) {
        try {
            return (int) obj;
        } catch (Exception e) {
            log.error("整数转Double失败：{}", e);
        }
        return null;
    }

    /**
     * 转String
     */
    public static String toString(Object obj) {
        try {
            if (!isEmpty(obj)) {
                return obj.toString();
            } else {
                log.error("对象为空，转换失败！");
            }
        } catch (Exception e) {
            log.error("转String失败：{}", e);
        }
        return null;
    }

    /**
     * 转Double
     */
    public static Double toDouble(Object obj) {
        try {
            if (!isEmpty(obj)) {
                return Double.parseDouble(obj.toString());
            } else {
                log.error("对象为空，转换失败！");
            }
        } catch (Exception e) {
            log.error("转Double失败：{}", e);
        }
        return null;
    }

    /**
     * 转Long
     */
    public static Long toLong(Object obj) {
        try {
            if (!isEmpty(obj)) {
                return Long.parseLong(obj.toString());
            } else {
                log.error("对象为空，转换失败！");
            }
        } catch (Exception e) {
            log.error("转Long失败：{}", e);
        }
        return null;
    }

    /**
     * 校验是否是double数据
     */
    public static boolean isDouble(Object obj) {
        try {
            Double.parseDouble(obj.toString());
        } catch (Exception e) {
            log.error("校验是否是double数据异常：{}", e);
            return false;
        }
        return true;
    }

    /**
     * 转BigDecimal
     */
    public static BigDecimal toBigDecimal(Object obj) {
        try {
            if (isNotEmpty(obj)) {
                if (isDouble(obj)) {
                    return BigDecimal.valueOf(toDouble(obj));
                } else {
                    log.error("对象不是double数据，不能转换成BigDecimal");
                }
            } else {
                log.error("对象为空，转换失败");
            }
        } catch (Exception e) {
            log.error("转BigDecimal异常：{}", e);
        }
        return null;
    }

    private static Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");

    /**
     * 是否为正整数
     */
    public static boolean isInteger(String str) {

        return pattern.matcher(str).matches();
    }

    public static boolean compareNumber(BigDecimal number) {
        if (!"".equals(number) && number != null) {
            if (new BigDecimal(number.intValue()).compareTo(number) == 0) {
                //整数
                return true;
            } else {
                //小数
                return false;
            }
        }
        return false;
    }

    public static String blobString(String obj) {
        String string = null;
        try {
            if (obj == null || "".equals(obj)) {
                return "";
            }
            Blob b = new SerialBlob(obj.getBytes("GBK"));
            string = new String(b.getBytes(1, (int) b.length()), "GBK");//blob 转 String
        } catch (UnsupportedEncodingException e) {
            log.error("blob转String异常：{}", e);
        } catch (SerialException e) {
            log.error("blob转String异常：{}", e);
        } catch (SQLException e) {
            log.error("blob转String异常：{}", e);
        }
        return string;
    }

    public static String getBytes(String str) {
        try {
            if (str.equals(new String(str.getBytes(ISO8859_1), ISO8859_1))) {
                str = new String(str.getBytes(ISO8859_1), "utf-8");
            }
        } catch (UnsupportedEncodingException e) {
            log.error("getBytes异常：{}", e);
        }
        return str;
    }

    /**
     * 获取卡号 截取一位 是生成条形码13位
     */
    public static String getCode() {
        Long date = System.currentTimeMillis();
        return date.toString().substring(1);
    }

    public static String getpath(HttpServletRequest request) {
        return request.getScheme() + "://" + request.getServerName()  // 服务器地址
            + request.getContextPath() // 项目名称
            + request.getServletPath() // 请求页面或其他地址
            + (CommonUtil.isEmpty(request.getQueryString()) ? "" : "?" + request.getQueryString()); // 参数
    }

    /**
     * 格式化字符串
     *
     * @param format
     * @param args
     * @return
     */
    public static String format(String format, Object... args) {
        String str = null;
        try {
            str = String.format(format, args);
        } catch (Exception e) {
            str = format;
            e.printStackTrace();
        }

        return str;
    }

    /**
     * 精确的减法运算
     *
     * @param v1 v1
     * @param v2 v2
     * @return v1-v2
     */
    public static double subtract(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 精确的乘法运算
     *
     * @param v1 v1
     * @param v2 v2
     * @return v1+v2
     */
    public static double multiply(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 精确的加法运算
     *
     * @param v1 v1
     * @param v2 v2
     * @return v1*v2
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 除法
     *
     * @param v1    v1
     * @param v2    v2
     * @param scale 保留小数
     * @return v1/v2
     */
    public static double div(double v1, double v2, int scale) {
        if (scale < 0) {
            return 0;
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    private static final int DEF_DIV_SCALE = 10;

    /**
     * 除法返回 整数
     *
     * @param d1 d1
     * @param d2 d2
     * @return 整数
     */
    public static Integer divInteger(double d1, double d2) {
        return (int) div(d1, d2, DEF_DIV_SCALE);

    }

    /**
     * 保留2位小数（四舍五入）
     */
    public static Double getDecimal(Double d) {
        if (d != null) {
            if (d.toString().split("\\.")[1].length() > 2) {
                BigDecimal bg = new BigDecimal(d.toString());
                return bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            } else {
                return d;
            }
        } else {
            return null;
        }

    }

    public static Double getDecimalStr(Double d, int len) {
        if (d != null && d.toString().split("\\.")[1].length() > 2) {
            len = len == 0 ? 2 : len;
            if (len > 0) {
                len = len + 1;
            }
            //    BigDecimal bg = new BigDecimal( d )
            int index = d.toString().indexOf('.') + len;
            return CommonUtil.toDouble(d.toString().substring(0, index));

        }
        return d;
    }

    private static final double PI = 3.14159265358979323; // 圆周率
    private static final double R  = 6371229; // 地球的半径

    /**
     * 获取两点间的距离
     *
     * @param longt1 经度1
     * @param lat1   纬度1
     * @param longt2 经度2
     * @param lat2   纬度2
     * @return
     */
    public static double getDistance(double longt1, double lat1, double longt2, double lat2) {
        double x;
        double y;
        double distance;
        x = (longt2 - longt1) * PI * R * Math.cos(((lat1 + lat2) / 2) * PI / 180) / 180;
        y = (lat2 - lat1) * PI * R / 180;
        distance = Math.hypot(x, y);
        if (distance > 0) {
            return distance;
        } else {
            return 0.0;
        }
    }

    private static Random rand = new Random();

    /**
     * 获取推荐码 6位
     *
     * @return
     */
    public static String getPhoneCode() {
        StringBuilder buf = new StringBuilder("1,2,3,4,5,6,7,8,9,0");
        String[]      arr = buf.toString().split(",");
        StringBuilder sb  = new StringBuilder();
        for (int i = 0; i < 6; i++) {
            Integer count = arr.length;
            int     a     = rand.nextInt(count);
            sb.append(arr[a]);
        }
        return sb.toString();
    }

    /**
     * 判断浏览器
     *
     * @return 1:微信浏览器,99:其他浏览器
     */
    public static Integer judgeBrowser(HttpServletRequest request) {
        Integer result = null;
        String  ua     = request.getHeader("user-agent").toLowerCase();
        if (ua.indexOf("micromessenger") > 0) {// 微信-1
            result = 1;
        } else {//其他 -99
            result = 99;
        }
        return result;
    }

    /**
     * 返回json数据到客户端
     */
    public static void write(HttpServletResponse response, Object obj) throws IOException {
        if (obj instanceof List || obj instanceof Object[]) {
            response.getWriter().print(JSONArray.toJSON(obj));
        } else if (obj instanceof Boolean || obj instanceof Integer || obj instanceof String || obj instanceof Double) {
            Map<String, Object> result = new HashMap<>();
            result.put("status", obj);
            response.getWriter().print(JSONObject.parseObject(JSON.toJSONString(result)));
        } else {
            response.getWriter().print(JSONObject.parseObject(JSON.toJSONString(obj)));
        }
        response.getWriter().flush();
        response.getWriter().close();
    }

    /**
     * 获取IP
     *
     * @param request
     * @return
     */
    public static String getIpAddr(HttpServletRequest request) {
        String ip      = request.getHeader("x-forwarded-for");
        String unknown = "unknown";
        if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        if ("0:0:0:0:0:0:0:1".equals(ip)) {
            ip = "127.0.0.1";
        }
        return ip;
    }

    /**
     * 把用户集合改成用逗号隔开的字符串
     */
    public static String getMememberIds(List<Integer> memberList, Integer memberId) {
        StringBuilder memberIds = new StringBuilder();
        if (memberList != null && !memberList.isEmpty()) {
            for (Integer id : memberList) {
                memberIds.append(id).append(",");
            }
            memberIds = new StringBuilder(memberIds.substring(0, memberIds.length() - 1));
        } else if (CommonUtil.isNotEmpty(memberId)) {
            memberIds = new StringBuilder(memberId.toString());
        }
        return memberIds.toString();
    }

    /**
     * 手机号码验证正则表达式
     */
    private static Pattern phonePattern = Pattern.compile("(^(13[0123456789][0-9]{8}|15[0123456789][0-9]{8}|18[0123456789][0-9]{8}|147[0-9]{8}|1349[0-9]{7})$)");

    /**
     * 手机号验证
     */
    public static boolean isPhone(String phone) {
        if (StringUtils.isEmpty(phone)) {
            return false;
        }

        Matcher matcher = phonePattern.matcher(phone);
        return matcher.matches();
    }

    /**
     * 在提交订单页面运费
     *
     * @param storeMap        店铺对象
     * @param memberLangitude 纬度
     * @param memberLongitude 经度
     * @return 运费
     */
    public static double getRaill(Map<String, Object> storeMap, Double memberLangitude, Double memberLongitude) {
        if (CommonUtil.isEmpty(memberLangitude) || CommonUtil.isEmpty(memberLongitude) || CommonUtil.isEmpty(storeMap)) {
            return 0;
        }
        if (CommonUtil.isEmpty(storeMap.get("stoLongitude")) || CommonUtil.isEmpty(storeMap.get("stoLatitude"))) {
            return 0;
        }
        double shopLongitude = CommonUtil.toDouble(storeMap.get("stoLongitude"));//店铺经度
        double shopLangitude = CommonUtil.toDouble(storeMap.get("stoLatitude"));//店铺纬度
        double raill         = 0;//粉丝到店铺的距离
        if (shopLangitude > 0 && shopLongitude > 0 && memberLangitude > 0 && memberLongitude > 0) {
            raill = CommonUtil.getDistance(memberLongitude, memberLangitude, shopLongitude, shopLangitude);
            raill = raill / 1000;
        }
        return raill;
    }

    /**
     * 小数处理（格式化）
     */
    public static Double formatDoubleNumber(Double number) {
        if (isEmpty(number)) {
            return 0D;
        }
        //        DecimalFormat df = new DecimalFormat( "######0.00" );
        NumberFormat nf = NumberFormat.getNumberInstance();
        // 保留两位小数
        nf.setMaximumFractionDigits(2);
        //不按照千分位输出
        nf.setGroupingUsed(false);
        // 如果不需要四舍五入，可以使用RoundingMode.DOWN
        nf.setRoundingMode(RoundingMode.HALF_UP);
        return CommonUtil.toDouble(nf.format(number));
    }

    /**
     * 小数处理 把数字转成用逗号隔开的
     */
    public static Double formatDoubleDou(BigDecimal number) {
        DecimalFormat df = new DecimalFormat(",###.00");
        return CommonUtil.toDouble(df.format(number));
    }

    /**
     * 小数处理 把数字转成用逗号隔开的
     */
    public static Double formatDoubleDou(Double number) {
        DecimalFormat df = new DecimalFormat(",###.00");
        return CommonUtil.toDouble(df.format(number));
    }

    /**
     * 获取页数
     *
     * @param rowCount 总条数
     * @param pageSize 每页显示的数量
     * @return
     */
    public static Integer getPageCount(int rowCount, int pageSize) {
        if (rowCount % pageSize == 0) {
            return rowCount / pageSize;
        } else {
            return rowCount / pageSize + 1;
        }
    }

    public static String getDays(String day) {
        String dayStr = "";
        switch (day) {
            case "1":
                dayStr = "周一";
                break;
            case "2":
                dayStr = "周二";
                break;
            case "3":
                dayStr = "周三";
                break;
            case "4":
                dayStr = "周四";
                break;
            case "5":
                dayStr = "周五";
                break;
            case "6":
                dayStr = "周六";
                break;
            default:
                dayStr = "周日";
                break;
        }
        return dayStr;
    }

    public static String getStr(String msg, int len, boolean isShowDian) {
        if (isNotEmpty(msg) && msg.length() > len) {
            msg = msg.substring(0, len);
            if (isShowDian) {
                msg += "...";
            }
        }
        return msg;
    }

    /**
     * 从后面开始截取
     *
     * @param msg
     * @param len
     * @return
     */
    public static String getAfterStr(String msg, int len) {
        if (msg.length() > len) {
            msg = msg.substring(msg.length() - len, msg.length());
        }
        return msg;
    }

    /**
     * 保留两位小数
     *
     * @param d
     * @return
     */
    public static BigDecimal getBigDecimal_2(Object d) {
        if (isNotEmpty(d)) {
            BigDecimal bg = new BigDecimal(d.toString());
            return bg.setScale(2, BigDecimal.ROUND_HALF_UP);
        }
       return null;
    }


    /**
     * 图片截取
     *
     * @param url
     * @return
     */
    public static String imageUrlSpilt(String url) {
        String   newUrl = url;
        String[] u      = url.split("upload/");
        if (u.length > 1) {
            newUrl = u[0];
        }
        return newUrl;
    }

    public static String imageUrlSub(String newUrl) {
        if (isEmpty(newUrl)) {
            return "";
        }
        if (newUrl.contains("/upload/")) {
            newUrl = newUrl.substring(newUrl.indexOf("/upload/") + 8, newUrl.length());
        } else if (newUrl.contains("upload/")) {
            newUrl = newUrl.substring(newUrl.indexOf("upload/") + 7, newUrl.length());
        }
        return newUrl;
    }

    public static String getSubUtil(String soap, String rgex) {
        StringBuilder str     = new StringBuilder();
        Pattern       pattern = Pattern.compile(rgex);// 匹配的模式
        Matcher       m       = pattern.matcher(soap);
        while (m.find()) {
            int i = 1;
            str.append(m.group(i));
            i++;
        }
        return str.toString();
    }

    public static String filterEmoji(String source) {
        if (source != null) {
            Pattern emoji        = Pattern.compile("[\ud83c\udc00-\ud83c\udfff]|[\ud83d\udc00-\ud83d\udfff]|[\u2600-\u27ff]", Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);
            Matcher emojiMatcher = emoji.matcher(source);
            if (emojiMatcher.find()) {
                source = emojiMatcher.replaceAll("*");
                return source;
            }
            return source;
        }
        return source;
    }

    public static <T> TreeMap<String, Object> beanToTreeMap(T bean) {
        Assert.notNull(bean, "bean is null");
        TreeMap<String, Object> map     = Maps.newTreeMap();
        BeanMap                 beanMap = BeanMap.create(bean);
        Iterator                var3    = beanMap.keySet().iterator();

        while (var3.hasNext()) {
            Object key = var3.next();
            if (Objects.nonNull(beanMap.get(key))) {
                map.put(key + "", beanMap.get(key));
            }
        }

        return map;
    }

    //mysql的模糊查询时特殊字符转义
    public static String escapeChar(String before) {
        if (isNotEmpty(before)) {
            before = before.replace("\\", "\\\\\\\\");
            before = before.replaceAll("_", "\\\\_");
            before = before.replaceAll("%", "\\\\%");
            before = before.replaceAll("'", "\\\\'");
            before = filterEmojis(before);
            before = before.trim();
        }
        return before;
    }

    public static String escapeCharLike(String before) {
        if (isNotEmpty(before)) {
            StringBuilder buf =  new StringBuilder();
            char[] chars = before.toCharArray();
            for (int i = 0; i < chars.length; i++) {
                String s1 = String.valueOf(chars[i]);
                buf.append(s1);
                if(!Character.isSpace(chars[i])){
                    buf.append("%");
                }
            }
            return buf.toString();
        }
        return before;
    }

    public static String escapeRemoveLike(String before) {
        if (isNotEmpty(before)) {
            before = before.replaceAll("\\\\%", "/u0025");
            before = before.replaceAll("%", "");
            before = before.replaceAll("/u0025", "%");
        }
        return before;
    }

    private static boolean isEmojiCharacter(char codePoint) {
        return (codePoint == 0x0) || (codePoint == 0x9) || (codePoint == 0xA)
            || (codePoint == 0xD)
            || ((codePoint >= 0x20) && (codePoint <= 0xD7FF))
            || ((codePoint >= 0xE000) && (codePoint <= 0xFFFD))
            || ((codePoint >= 0x10000) && (codePoint <= 0x10FFFF));
    }

    /**
     * 过滤emoji 或者 其他非文字类型的字符
     *
     * @param source
     * @return
     */
    public static String filterEmojis(String source) {
        if (isEmpty(source)) {
            return source;
        }
        StringBuilder buf = null;
        int           len = source.length();
        for (int i = 0; i < len; i++) {
            char codePoint = source.charAt(i);
            if (isEmojiCharacter(codePoint)) {
                if (buf == null) {
                    buf = new StringBuilder(source.length());
                }
                buf.append(codePoint);
            }
        }
        if (buf == null) {
            return source;
        } else {
            if (buf.length() == len) {
                buf = null;
                return source;
            } else {
                return buf.toString();
            }
        }
    }

    /**
     * 实体类对象转URL参
     *
     * @param t         实体类对象
     * @param callSuper 是否转换父类成员
     * @param <T>       实体类泛型
     * @return a=1&b=2
     */
    public static <T> String entityToUrlParam(T t, boolean callSuper) {
        // URL 参数存储器
        StringBuffer urlParam = new StringBuffer();
        //扩展转换父类成员功能
        entitySuperclassToUrlParam(t, t.getClass(), callSuper, urlParam);
        if (urlParam.length() > 0) {
            //去除最后一个&字符
            urlParam.deleteCharAt(urlParam.length() - 1);
        }
        return urlParam.toString();
    }

    /**
     * 实体类对象转URL参
     *
     * @param t         实体类对象
     * @param clazz     实体类类型
     * @param callSuper 是否转换父类成员
     * @param urlParam  URL 参数存储器
     * @param <T>       实体类泛型
     * @return a=1&b=2
     */
    @Deprecated
    public static <T> void entitySuperclassToUrlParam(T t, Class clazz, boolean callSuper, StringBuffer urlParam) {
        //如果实体类对象为Object类型，则不处理
        if (!clazz.equals(Object.class)) {
            //获取实体类对象下的所有成员，并保存到 URL 参数存储器中
            Arrays.stream(clazz.getDeclaredFields()).forEach(field -> {
                //如果是编译过程中加入的属性 跳过
                if (field.isSynthetic()) {
                    return;
                }
                //设置可以操作私有成员
                field.setAccessible(true);
                try {
                    //获取成员值
                    Object value = field.get(t);
                    //成员值为 Null 时，则不处理
                    if (Objects.nonNull(value)) {
                        urlParam.append(field.getName()).append("=").append(value).append("&");
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            });
            //是否转换父类成员
            if (callSuper) {
                //获取父类类型
                clazz = clazz.getSuperclass();
                //递归调用，获取父类的处理结果
                entitySuperclassToUrlParam(t, t.getClass(), callSuper, urlParam);
            }
        }
    }

   


      

    /**
     * 匹配是否为数字
     * @param str 可能为中文，也可能是-19162431.1254，不使用BigDecimal的话，变成-1.91624311254E7
     * @return
     */
    public static boolean isNumeric(String str) {
        // 该正则表达式可以匹配所有的数字 包括负数
        Pattern pattern = Pattern.compile("-?[0-9]+(\\.[0-9]+)?");
        String bigStr;
        try {
            bigStr = new BigDecimal(str).toString();
        } catch (Exception e) {
            return false;//异常 说明包含非数字。
        }

        Matcher isNum = pattern.matcher(bigStr); // matcher是全匹配
        if (!isNum.matches()) {
            return false;
        }
        return true;
    }


    public static boolean isContainChinese(String str) {
        Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
        Matcher m = p.matcher(str);
        if (m.find()) {
            return true;
        }

        return false;
    }

    /**
     * Returns a String where those characters that QueryParser
     * expects to be escaped are escaped by a preceding <code>\</code>.
     */
    public static String escape(String s) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            // These characters are part of the query syntax and must be escaped
            if (c == '\\' || c == '+' || c == '-' || c == '!' || c == '(' || c == ')' || c == ':'
                || c == '^' || c == '[' || c == ']' || c == '\"' || c == '{' || c == '}' || c == '~'
                || c == '*' || c == '?' || c == '|' || c == '&' || c == '/') {
                sb.append('\\');
            }
            sb.append(c);
        }
        return sb.toString();
    }

    public static boolean stringEq(String va1,String va2) {
        boolean isResult=true;
        try {
            if (isEmpty(va1) && isEmpty(va2)) {
                return true;
            }
            if (isEmpty(va1) ) {
                va1="";
            }
            if (isEmpty(va2) ) {
                va2="";
            }
            return va1.equals(va2);
        } catch (Exception e) {
            log.error("String比较失败：{}", e);
        }
        return isResult;
    }

    /**
     * 基础值的加减乘除运算
     * @param formulaMode 计算方式 1加 2减 3乘 4除
     * @param presentPrice 当前金额
     * @param setPrice 需要设置/计算的金额
     * @param highPrice 最大金额 超过计算 将附此值  可为null
     * @return 最低0.01 最高不大于当前金额（presentPrice） 无运算取setPrice（设置金额）
     */
    public static BigDecimal getFormulaMode(Integer formulaMode, BigDecimal presentPrice, BigDecimal setPrice, BigDecimal highPrice) {
        if (CommonUtil.isEmpty(formulaMode)) formulaMode = 0;
        BigDecimal formulaModePrice = setPrice;
        //加减乘除计算
        switch (formulaMode) {
            case 1:
                formulaModePrice = BigDecimalUtil.defAdd(presentPrice, setPrice);
                break;
            case 2:
                formulaModePrice = BigDecimalUtil.defSub(presentPrice, setPrice);
                break;
            case 3:
                formulaModePrice = BigDecimalUtil.defMul(presentPrice, setPrice);
                break;
            case 4:
                formulaModePrice = BigDecimalUtil.defDiv(presentPrice, setPrice);
                break;
        }
        if (!BigDecimalUtil.compareZero(BigDecimalUtil.getBigDecimal_2(formulaModePrice))) {
            formulaModePrice = BigDecimalUtil.getBigDecimal_2(0.01);
        }
        if (CommonUtil.isNotEmpty(highPrice) && BigDecimalUtil.compareSize(formulaModePrice, highPrice)) {
            formulaModePrice = highPrice;
        }
        return formulaModePrice;
    }

    public static class SpiltUtil<T> {

        public Map<Integer, List<T>> spiltList(List<T> historyList, int size) {
            int                   listSize = historyList.size();
            Map<Integer, List<T>> map      = new HashMap<>();     //用map存起来新的分组后数据
            int                   keyToken = 0;
            for (int i = 0; i < historyList.size(); i += size) {
                if (i + size > listSize) {        //作用为toIndex最后没有100条数据则剩余几条newList中就装几条
                    size = listSize - i;
                }
                List<T> newList = historyList.subList(i, i + size);
                map.put(keyToken, newList);
                keyToken++;
            }
            System.out.println("一共切分了" + map.size() + "个list");
            return map;
        }
    }

    /**
     * 正则去除.或多余的0
     *
     * @param obj 需要去除的参数
     */
    public static String removeZeros(Object obj) {
        if (isEmpty(obj)) {
            return "0";
        }
        String num = obj.toString();
        if (num.indexOf(".") > 0) {
            // 去掉多余的0
            num = num.replaceAll("0+?$", "");
            // 如果最后一位是. 则去掉
            num = num.replaceAll("[.]$", "");
        }
        return num;
    }

}