CODEWITHSUNDEEP
javajsongson
Atom
Atom

Reputation: 375

Collect all elements in a JSON file into a single list

I am using Gson 2.8.1+ (I can upgrade if needed).

If I have the JsonObject:

"config" : {
        "option_one" : {
            "option_two" : "result_one"
        }
    }
}

... how can I convert this efficiently to the form:

"config.option_one.option_two" : "result_one"

Upvotes: 2

Views: 375

Answers (3)

terrorrussia-keeps-killing
terrorrussia-keeps-killing

Reputation: 1787

Gson does not have anything like that, but it provides enough capabilities to build it on top: you can walk JSON streams (JsonReader) and trees (JsonElement, but not wrapped into JsonReader) stack-based and stack-based/recursively accordingly (streams may save much).

I would create a generic tree-walking method to adapt it for further purposes.

public static void walk(final JsonElement jsonElement, final BiConsumer<? super Collection<?>, ? super JsonElement> consumer) {
    final Deque<Object> parents = new ArrayDeque<>();
    parents.push("$");
    walk(jsonElement, consumer, parents);
}

private static void walk(final JsonElement jsonElement, final BiConsumer<? super Collection<?>, ? super JsonElement> consumer, final Deque<Object> path) {
    if ( jsonElement.isJsonNull() ) {
        consumer.accept(path, jsonElement);
    } else if ( jsonElement.isJsonPrimitive() ) {
        consumer.accept(path, jsonElement);
    } else if ( jsonElement.isJsonObject() ) {
        for ( final Map.Entry<String, JsonElement> e : jsonElement.getAsJsonObject().entrySet() ) {
            path.addLast(e.getKey());
            walk(e.getValue(), consumer, path);
            path.removeLast();
        }
    } else if ( jsonElement.isJsonArray() ) {
        int i = 0;
        for ( final JsonElement e : jsonElement.getAsJsonArray() ) {
            path.addLast(i++);
            walk(e, consumer, path);
            path.removeLast();
        }
    } else {
        throw new AssertionError(jsonElement);
    }
}

Note that the method above also supports arrays. The walk method is push-semantics-driven: it uses callbacks to provide the walk progress. Making it lazy by returning an iterator or a stream would probably be cheaper and get the pull semantics applied. Also, CharSequence view elements would probably save on creating many strings.

public static String toJsonPath(final Iterable<?> path) {
    final StringBuilder stringBuilder = new StringBuilder();
    final Iterator<?> iterator = path.iterator();
    if ( iterator.hasNext() ) {
        final Object next = iterator.next();
        stringBuilder.append(next);
    }
    while ( iterator.hasNext() ) {
        final Object next = iterator.next();
        if ( next instanceof Number ) {
            stringBuilder.append('[').append(next).append(']');
        } else if ( next instanceof CharSequence ) {
            stringBuilder.append('.').append(next);
        } else {
            throw new UnsupportedOperationException("Unsupported: " + next);
        }
    }
    return stringBuilder.toString();
}

Test:

final JsonElement jsonElement = Streams.parse(jsonReader);
final Collection<String> paths = new ArrayList<>();
JsonPaths.walk(jsonElement, (path, element) -> paths.add(JsonPaths.toJsonPath(path)));
for ( final String path : paths ) {
    System.out.println(path);
}
Assertions.assertIterableEquals(
        ImmutableList.of(
                "$.nothing",
                "$.number",
                "$.object.subobject.number",
                "$.array[0].string",
                "$.array[1].string",
                "$.array[2][0][0][0]"
        ),
        paths
);

Upvotes: 0

Rubydesic
Rubydesic

Reputation: 3476

Simple example:

public static void main(String[] args) {
    String str = """
    {
        "config" : {
            "option_one" : {
                "option_two" : "result_one"
            }
        }
    }""";
    var obj = JsonParser.parseString(str).getAsJsonObject();
    System.out.println(flatten(obj)); // {"config.option_one.option_two":"result_one"}
}

public static JsonObject flatten(JsonObject toFlatten) {
    var flattened = new JsonObject();
    flatten0("", toFlatten, flattened);
    return flattened;
}

private static void flatten0(String prefix, JsonObject toFlatten, JsonObject toMutate) {
    for (var entry : toFlatten.entrySet()) {
        var keyWithPrefix = prefix + entry.getKey();
        if (entry.getValue() instanceof JsonObject child) {
            flatten0(keyWithPrefix + ".", child, toMutate);
        } else {
            toMutate.add(keyWithPrefix, entry.getValue());
        }
    }
}

Upvotes: 2

Jakub D&#243;ka
Jakub D&#243;ka

Reputation: 2625

Algorithm

Simplest algorithm you can come up with is recursive folding. You first dive recursively to the bottom of a structure, then ask if there is only one element in the map(you have to parse json with some framework to get a Map<string, object> structure). If there is, you join the string of parent field with property and set value of parent to value of that property. Then you move up and repeat the process until you are at the root. Of course, if map has multiple fields, you will move on to the parent and try egan.

Upvotes: 2

Related Questions