2
votes

Comment convertir un LinkedHashMap > en JSONObject?

Je suis nouveau chez JSONObject et j'essaye de convertir un LinkedHashMap > en un fichier json. La carte est structurée de la manière suivante:

{
"element_one": [
{
"items": [
  {
    "value": "1",
    "label": "Donald"
  },
  {
    "value": "2",
    "label": "Goofy"
  }]
}],

"element_two": [
{
"items": [
  {
    "value": "1",
    "label": "Peter"
  },
  {
    "value": "2",
    "label": "Wendy"
  }]
}}

Chaque nœud a deux propriétés: valeur et étiquette.

Ce que je veux, c'est quelque chose comme ceci:

"element_one", {Node1, Node2, etc...}
"element_two", {Node1, Node2, etc...}

J'utilise JSONObject et j'ai cherché une solution dans un thread différent mais rien ne m'a aidé. Je sais que c'est une question particolaire, mais j'ai besoin d'avoir ce résultat avec cette structure de données.

Le point dur est de boucler l'élément de nœuds à l'intérieur de la carte sans écraser les éléments déjà insérés dans le JSONObject.

Merci.

java json linkedhashmap jsonconvert

0 commentaires

3 Réponses :

0
votes

La bibliothèque GSON vous aidera à convertir un objet en JSON.

<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>

Dépendance Maven

Gson gson = new Gson();
String json = gson.toJson(myMap,LinkedHashMap.class);

0 commentaires

0
votes

Vous pouvez utiliser stream pour convertir LinkedHashMap en JsonObject:

Node -class (par exemple ):

 Map<String, List<Node>> nodes = ...
 JsonObject jo = nodes
            .entrySet()
            .stream()
            .map((e) -> Json.createObjectBuilder().add(e.getKey(), toItems(e.getValue()))
            ).collect(
                    Collector.of(
                            Json::createObjectBuilder,
                            JsonObjectBuilder::addAll,
                            JsonObjectBuilder::addAll,
                            JsonObjectBuilder::build
                    )
            );

toItems -method convert value ( List ) => mapper les nœuds aux constructeurs et les collecter en utilisant collector ( Collector.of (...) ) à "items" JsonObject:

static JsonObject toItems(List<Node> nodes) {
    return nodes
            .stream()
            .map(node ->
                    Json.createObjectBuilder()
                            .add("value", node.getValue())
                            .add("label", node.getLabel())
           ).collect(
                    Collector.of(
                            Json::createArrayBuilder,
                            JsonArrayBuilder::add,
                            JsonArrayBuilder::addAll,
                            jsonArrayBuilder ->
                                    Json.createObjectBuilder()
                                            .add("items", jsonArrayBuilder)
                                            .build()
                    )
            );
}

Stream de Map.Entry > convertit chaque Entry en JsonObject et collecter tout dans Root

public class Node {
    private final String value;
    private final String label;

    private Node(String value, String label) {
        this.value = value;
        this.label = label;
    }

    //Getters
}

0 commentaires

0
votes

Je l'ai résolu en combinant la classe JSONArray et JSONObject.

J'ai créé l'objet principal en utilisant une boucle pour tous les nœuds:

jsonArrayFinal.toString();

Ensuite, placez le jsonArrayOne dans un jsonObject:

jsonArrayFinal.put(jsonObjTwo);

Et mettez ce jsonObjOne dans un jsonArray:

jsonObjTwo.put(element, jsonArrayTwo);

Mettez ce jsonArrayTwo dans un jsonObject: p>

jsonArrayTwo.put(jsonObjOne);

Enfin, mettez ce jsonObjTwo dans le jsonArrayFinal.

jsonObjOne.put("items", jsonArrayOne);

À la fin, j'ai converti le jsonArrayFinal en une chaîne: p >

for (Node node : nodeList)
{
  try
  {
     JSONObject obj = new JSONObject();
     obj.put("value", node.getValue());
     obj.put("label", node.getLabel());
     jsonArrayOne.put(obj)
  }
  catch (JSONException e)
  {
     log.info("JSONException");
  }
}

0 commentaires