xml to json

src/main/java/com/scbfkj/uni/library/MapTools.java

@@ -0,0 +1,298 @@
+package com.scbfkj.uni.library;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+
+import java.io.*;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.text.ParseException;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class MapTools implements Serializable {
+
+
+
+    private static Object mapStrToObj(String inMapStr, List<Object> itemMapList, String... strType) {//
+        String beginChar = strType.length == 0 ? "{" : "[";//为了递归数组准备
+        String endChar = strType.length == 0 ? "}" : "]"; //}
+        String midChar = strType.length < 2 ? "=" : strType[1];//兼容JSON格式
+        itemMapList = (Objects.isNull(itemMapList) || itemMapList.isEmpty()) ? new ArrayList<>() : itemMapList;//中间计算结果：从入口进入是为了递归数组准备
+        String tempMapStr = inMapStr;//为避免入口参数污染 [A]
+        while (true) {//遍历字符串
+            int lastLocation = tempMapStr.lastIndexOf(beginChar);//查找最后一个{，一定是独立层，无论在哪 《0》
+            int mapEndLocation = tempMapStr.indexOf(endChar, lastLocation);//查找第一个匹配的内容
+            if (lastLocation < 0 || mapEndLocation < 0) break;//找不到代表数据遍历完或数据格式有错误
+            String itemMapStr = tempMapStr.substring(lastLocation, mapEndLocation + 1);//获取一个子MAP，注意不要去掉两头括号，方便进行计算替换[1]
+            String replaceStr = itemMapStr;//为后面替换进行准备，避免数据污染 {A=[a]}
+            if (itemMapStr.indexOf("[") > 0 && itemMapStr.indexOf("]") > 0) {
+                Map<String, Object> tempObj = (Map<String, Object>) mapStrToObj(itemMapStr, itemMapList, "arr");
+                itemMapStr = tempObj.get("itemMapStr").toString();
+                itemMapList = (List<Object>) tempObj.get("itemMapList");
+            }
+            String[] columnList = itemMapStr.replace(beginChar, "").replace(endChar, "").replaceAll("\"", "").split(",", -1);//使用逗号分割 //
+            Map<String, Object> itemMap = new HashMap<>();
+            List<Object> itemList = new ArrayList<>();
+            for (String s : columnList) { //s= [1]
+                Object columnValue = "";
+                String keyName = null;
+                if (strType.length == 0) { //
+                    //{A="12:00:00"}
+                    midChar = !s.contains(":") ? "=" : !s.contains("=") ? ":" : s.indexOf("=") > s.indexOf(":") ? ":" : "=";
+                    String[] colValue = s.split(midChar, -1); // [X1,1]
+                    if (s.contains(":") && s.lastIndexOf(":") > s.indexOf(":")) {
+                        keyName = colValue[0].replace("'", "").replace("\"", "").trim(); //X1
+                        columnValue = s.substring(s.indexOf(":") + 1);
+                    } else {
+                        if (colValue.length != 2) continue; //  || Objects.equals(colValue[0], "")
+                        keyName = colValue[0].replace("'", "").replace("\"", "").trim(); //X1
+                        columnValue = Objects.equals(colValue[1], "null") ? null : (colValue[1].trim()); //1 Objects.equals(colValue[1], "") ||
+                    }
+
+                } else {
+                    columnValue = s;
+                }
+                if (columnValue != null && columnValue.toString().startsWith("《") && columnValue.toString().endsWith("》")) {
+                    String columnValueIndex = columnValue.toString().replace("《", "").replace("》", "");
+                    if (!MapTools.isNumber(columnValueIndex)) continue;
+                    columnValue = itemMapList.get(Integer.parseInt(columnValueIndex));
+                }
+                if (strType.length == 0) {
+                    itemMap.put(keyName, columnValue); // X1,1
+                } else {
+                    itemList.add(columnValue);
+                }
+            }
+            tempMapStr = tempMapStr.replace(replaceStr, "《" + itemMapList.size() + "》");//用于父级获取对应的值   《0》
+            itemMapList.add(strType.length == 0 ? itemMap : itemList); //[{X1:1}]
+        }
+        if (tempMapStr.contains("[") && tempMapStr.contains("]")) {  // 《0》
+            Object tempMapData = mapStrToObj(" " + tempMapStr + " ", itemMapList, "arr", midChar);
+            tempMapStr = tempMapData.toString();
+        }
+        Map<Object, Object> temMap = new HashMap<>();
+        temMap.put("itemMapStr", tempMapStr);
+        temMap.put("itemMapList", itemMapList);
+        for (int i = 0; i < itemMapList.size(); i++) {
+            Object o = itemMapList.get(i);
+            if (o instanceof Map<?, ?> tempMap) {
+                Map<Object, Object> temp = new HashMap<>();
+                for (Map.Entry<?, ?> entry : tempMap.entrySet()) {
+                    Object value = entry.getValue();
+                    String key = entry.getKey().toString();
+                    if (value instanceof String str) {
+                        Matcher matcher = Pattern.compile("《\\d+》").matcher(str);
+                        if (matcher.find()) {
+                            String group = matcher.group();
+                            Integer index = Integer.parseInt(group.substring(1, group.length() - 1));
+                            temp.put(key, itemMapList.get(index));
+                            continue;
+                        }
+                    }
+
+                    temp.put(key, value);
+
+                }
+                itemMapList.set(i, temp);
+            } else {
+                System.out.println("1111");
+            }
+        }
+        itemMapList = cleanObject(itemMapList);
+        return strType.length == 0 ? (itemMapList.size() == 0 ? itemMapList : itemMapList.get(itemMapList.size() - 1)) : temMap;
+    }
+
+
+    private static <T> T cleanObject(T obj) {
+        if (obj instanceof Map<?, ?>) {
+            Map<String, ?> map = (Map<String, ?>) obj;
+            return (T) cleanMap(map);
+        } else if (obj instanceof Collection<?> collection) {
+            return (T) collection.stream().map(MapTools::cleanObject).toList();
+        } else if (obj instanceof String str) {
+            return (T) str.replaceAll("^\\\\+", "").replaceAll("\\\\+$", "");
+        } else {
+            return obj;
+        }
+    }
+
+    private static <V> Map<String, V> cleanMap(Map<String, V> map) {
+        Map<String, V> result = new HashMap<>();
+        for (Map.Entry<String, V> stringObjectEntry : map.entrySet()) {
+            String key = stringObjectEntry.getKey().toString().replaceAll("^\\\\+", "").replaceAll("\\\\+$", "");
+            V value = stringObjectEntry.getValue();
+
+            result.put(key, cleanObject(value));
+        }
+        return result;
+    }
+
+
+    /**
+     * java正则提取多个结果
+     *
+     * @param str     字符串
+     * @param pattern 正则表达式
+     * @return 匹配的结果集
+     */
+    public static List<String> patternContent(String str, String pattern) {
+        // 编写正则表达式
+        // 匹配当前正则表达式
+        Matcher matcher = Pattern.compile(pattern).matcher(str);
+        // 定义当前文件的文件名称
+        List<String> arrayList = new ArrayList<>();
+        // 判断是否可以找到匹配正则表达式的字符
+        while (matcher.find()) {
+            // 将匹配当前正则表达式的字符串即文件名称进行赋值
+            arrayList.add(matcher.group());
+        }
+        // 返回
+        return arrayList;
+    }
+
+
+    public static String patternKey(String str, String pattern) {
+        // 编写正则表达式
+        // 匹配当前正则表达式
+        Matcher matcher = Pattern.compile(pattern).matcher(str);
+        // 定义当前文件的文件名称
+        // 判断是否可以找到匹配正则表达式的字符
+        while (matcher.find()) {
+            // 将匹配当前正则表达式的字符串即文件名称进行赋值
+            return matcher.group();
+        }
+        // 返回
+        return null;
+    }
+
+    /**
+     * 获得字符串的值，如果是空字符串则为null
+     *
+     * @return xml标签值为空字符串：替换成null
+     */
+    public static String getText(String str) {
+        return MapTools.isBlank(str) ? null : str;
+    }
+
+    /**
+     * list 深拷贝
+     *
+     * @param src 源list
+     * @param <T> list中数据类型
+     * @return 返回拷贝后新list的值
+     */
+    public static <T> List<T> deepCopy(List<T> src) {
+        try {
+            ByteArrayOutputStream byteout = new ByteArrayOutputStream();
+            ObjectOutputStream out = new ObjectOutputStream(byteout);
+            out.writeObject(src);
+            ByteArrayInputStream bytein = new ByteArrayInputStream(byteout.toByteArray());
+            ObjectInputStream in = new ObjectInputStream(bytein);
+            @SuppressWarnings("unchecked") List<T> dest = (List<T>) in.readObject();
+            in.close();
+            return dest;
+        } catch (ClassNotFoundException | IOException e) {
+            return null;
+        }
+    }
+
+    public static <HashMap extends Serializable> HashMap clone(Map<String, Object> obj) {
+        HashMap clonedObj = null;
+        try {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            ObjectOutputStream oos = new ObjectOutputStream(baos);
+            oos.writeObject(obj);
+            ByteArrayInputStream bytein = new ByteArrayInputStream(baos.toByteArray());
+            ObjectInputStream ois = new ObjectInputStream(bytein);
+            clonedObj = (HashMap) ois.readObject();
+            ois.close();
+        } catch (Exception e) {
+            return null;
+        }
+        return clonedObj;
+    }
+
+    /**
+     * 从map中获取returnData获取List
+     *
+     * @param params
+     * @return
+     */
+
+    public static List<Map<String, Object>> getMapList(Map<String, Object> params) {
+        if (Objects.isNull(params.get("returnData"))) return null;
+        Object returnData = params.get("returnData");
+        if (returnData instanceof List) {
+            return (List<Map<String, Object>>) returnData;
+        } else {
+            return null;
+        }
+    }
+
+
+    /*字符串空判断*/
+    public static boolean isBlank(final String s) {
+        if (s == null || s.isEmpty()) {
+            return true;
+        }
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (!Character.isWhitespace(c)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /*字符串非空判断*/
+    public static boolean isNotBlank(final String s) {
+        return !isBlank(s);
+    }
+
+
+    /**
+     * 判断字符串是否是数字
+     *
+     * @param str 字符串
+     * @return 是数字：true ，否则false
+     */
+    public static boolean isNumber(String str) {
+        try {
+            Double.parseDouble(str);
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    public static Map<String, Object> processSuccess(Object returnData) {
+        Map<String, Object> returnMap = new HashMap<>();//用于当前方法统一返回参数，不存在深拷贝问题
+        returnMap.put("code", "0");
+        returnMap.put("returnData", returnData);
+        return returnMap;
+    }
+
+    //统一错误信息处理
+    public static Map<String, Object> processFail(String errorMessage) {
+        Map<String, Object> returnMap = new HashMap<>();//用于当前方法统一返回参数，不存在深拷贝问题
+        returnMap.put("code", "-1");
+        returnMap.put("message", errorMessage);
+        return returnMap;
+    }
+
+
+    public static String getMD5Str(String str) {
+        try {
+            MessageDigest md5 = MessageDigest.getInstance("md5");
+            byte[] digest = md5.digest(str.getBytes(StandardCharsets.UTF_8));
+            return new BigInteger(1, digest).toString(16);
+        } catch (NoSuchAlgorithmException e) {
+            e.printStackTrace();
+        }
+        //16是表示转换为16进制数
+        return null;
+    }
+}