fastjson把json合并成一层 json拍平

前言

JSON（JavaScript Object Notation）是一种常用的数据交换格式，它以键值对的形式表示数据，并使用大括号{}包围。JSON可以具有多个嵌套的层级，但在某些情况下，我们可能需要将其拍平为一个层级。

将JSON拍平为一个层级可以使数据更易于处理和分析。我们可以通过将嵌套层级展开，将所有的键值对组合成一个新的JSON对象，其中每个键都是唯一的。这样一来，我们可以更方便地对数据进行查询、过滤和操作。

在拍平JSON时，我们可以使用递归算法来处理嵌套的层级。递归算法可以遍历JSON对象的所有键值对，并将它们组合成一个新的层级。

拍平JSON的过程可以分为以下步骤：

1. 遍历JSON对象的所有键值对。
2. 如果值是一个嵌套的JSON对象，我们可以使用递归算法来处理它。递归算法会将嵌套的JSON对象展开，并将其键值对添加到新的层级中。
3. 将当前键值对添加到新的层级中。

json拍平，把json合成一个层级。

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;

import java.util.*;

@Slf4j
public class JsonParserUtil {

    /**
     * 拍平
     *
     * @param json
     * @return
     */
    public static JSONObject parser(JSONObject json) {
        JSONObject jsonObject = new JSONObject();
        if (json != null && json.size() > 0) {
            for (String k : json.keySet()) {
                Object v = json.get(k);
                if (v instanceof JSONArray) {
                    List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
                    Iterator<Object> it = ((JSONArray) v).iterator();
                    while (it.hasNext()) {
                        try {
                            JSONObject json2 = (JSONObject) it.next();
                            list.add(parser(json2));
                        } catch (Exception e) {
                            log.info(e.toString());
                        }
                    }
                    jsonObject.put(k, list);
                } else if (v instanceof JSONObject) {
                    List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
                    JSONObject child = (JSONObject) v;
                    for (String stk : child.keySet()) {
                        Object value = child.get(stk);
                        if (value instanceof JSONArray) {
                            Iterator<Object> it = ((JSONArray) value).iterator();
                            while (it.hasNext()) {
                                JSONObject json2 = (JSONObject) it.next();
                                list.add(parser(json2));
                            }
                        } else {
                            jsonObject.put(stk, value.toString());
                        }
                    }
                    if (list.size() > 0) {
                        for (int m = 0; m < list.size(); m++) {
                            Map<String, Object> chMap = list.get(m);
                            for (String chKey : chMap.keySet()) {
                                jsonObject.put(chKey, ObjectUtils.isNotEmpty(chMap.get(chKey)) ? chMap.get(chKey).toString() : null);
                            }
                        }
                    }
                } else {
                    jsonObject.put(k, v);
                }
            }
        }
        return jsonObject;
    }
}

拍平JSON后，我们可以得到一个层级扁平的JSON对象，其中所有的键都是唯一的。这样一来，我们可以更便捷地处理和分析数据。

总结起来，将JSON拍平为一个层级可以让数据更易于处理和分析。通过遍历JSON对象的所有键值对，并使用递归算法处理嵌套的层级，我们可以将JSON展开为一个层级扁平的对象。这样一来，我们可以更方便地对数据进行查询、过滤和操作。