（Java）使用Java8将JSONObject的JSONArray展平为[[]]

Question

Im使用net.sf.json.JSONArray和net . SF . JSON . JSONObject . JSON array包含多个JSON object。

基本上是这样的：

[
    {
        "obj1": [
            {
                "ID": 12
                "NAME":"Whatever",
                "XY":[1,2]
            },
            {
                "ID": 34
                "NAME":"Again",
                "XY":[23,43]
            },
            etc
        ]
    },
    { "obj2": repeat}
]

我想用Java 8来解决这个问题，即结果：

[
    {
        "obj1": [
                    [12,'Whatever',1,2],
                    [34,'Again',23,43],
                    etc...
        ]
    },
    { "obj2": repeat}
]

Answer 1

JSONArray array = ...;
JSONArray flattedArray = flatten(array);

JSONObject map = ...;
JSONObject flattedMap = flatten(map);

当json结构发生变化时，实现发生了巨大的变化，您可以在github上比较我的提交历史。测试可以告诉你我是如何实现你的功能的。

public JSONArray flatten(Collection<?> array) {
    return array.stream().flatMap(this::flatting).collect(toJSONArray());
}

private Stream<?> flatting(Object it) {
    if (it instanceof Collection) {
        return ((Collection<?>) it).stream();
    }
    if (it instanceof Map) {
        return Stream.of(flatten((Map<?, ?>) it));
    }
    return Stream.of(it);
}

public JSONObject flatten(Map<?, ?> map) {
    return map.entrySet().stream().collect(
            JSONObject::new,
            (it, field) -> it.put(field.getKey(), flatten(field.getValue())),
            JSONObject::putAll
    );
}

private Object flatten(Object it) {
    if (it instanceof Collection) {
        return ((Collection<?>) it).stream().map(this::flatten)
                                            .collect(toJSONArray());
    }
    if (it instanceof Map) {
        return flatten(((Map<?, ?>) it).values());
    }
    return it;
}

private <T> Collector<T, ?, JSONArray> toJSONArray() {
    return toCollection(JSONArray::new);
}

Answer 2

尽管您可以使用/out递归以命令式方式轻松完成此操作，但以函数式风格实现可能更容易。我不确定我是否擅长Java8中的惯用函数代码，但您需要：

< li >将项目收集到单个数组的收集器

static Collector<Object, JSONArray, JSONArray> toJSONArray() {
    return Collector.of(
            JSONArray::new,     // Create a new array
            JSONArray::add,     // Add each element to the target array
            (a1, a2) -> {       // Merge the second array into the first one
                a1.addAll(a2);
                return a1;
            },
            identity()          // Return the populated array itself
    );
}

• 一个递归的flatten方法（灵感来自Stream.flatMap（）的递归使用）。不确定它是否可以更容易地实现（Q43481457只是当前的类名）。

static Stream<?> flatten(final Object value) {
    return value instanceof Collection
            ? ((Collection<?>) value).stream().flatMap(Q43481457::flatten) // Flatten recursively
            : Stream.of(value);                                            // Otherwise wrap a single element into a stream
}

< li >和主代码:

@SupressWarnings("unchecked")
final Collection<JSON> jsonArray = (Collection<JSON>) originalJsonArray;
final JSONArray flatJSONArray = jsonArray.stream()
        .map(json -> (Map<?, ?>) json)          // All outer array elements are JSON objects and maps in particular
        .map(jsonObject -> jsonObject.values()  // Recursively flatten the JSON object values
                .stream()
                .flatMap(Q43481457::flatten)
                .collect(toJSONArray())         // ... collecting them to JSON arrays
        )
        .collect(toJSONArray());                // ... which are collected to JSON arrays
System.out.println(flatJSONArray);

输出：

[[12，“无论如何”，1，2]，[34，“再次”，23，43]]