Collect all elements in a JSON file into a single list

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.

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());
        }
    }
}

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
);