Comment convertir hashmap en objet JSON en Java

Gson peut également être utilisé pour sérialiser arbitrairement des objets complexes.

Voici comment vous l'utilisez:

Gson gson = new Gson(); 
String json = gson.toJson(myObject); 

Gson convertit automatiquement les collections en tableaux JSON. Gson peut sérialiser des champs privés et ignore automatiquement les champs transitoires.

Exemple en utilisant json

Map<String, Object> data = new HashMap<String, Object>();
    data.put( "name", "Mars" );
    data.put( "age", 32 );
    data.put( "city", "NY" );
    JSONObject json = new JSONObject();
    json.putAll( data );
    System.out.printf( "JSON: %s", json.toString(2) );

Sortie::

JSON: {
  "age": 32,
  "name": "Mars",
  "city": "NY"
}

Vous pouvez également essayer d'utiliser GSON de Google.GSON de Google est la meilleure bibliothèque disponible pour convertir des objets Java en leur représentation JSON.

Http://code.google.com/p/google-gson/

, Vous pouvez convertir Map à JSON utiliser Jackson comme suit:

Map<String,Object> map = new HashMap<>();
//You can convert any Object.
String[] value1 = new String[] { "value11", "value12", "value13" };
String[] value2 = new String[] { "value21", "value22", "value23" };
map.put("key1", value1);
map.put("key2", value2);
map.put("key3","string1");
map.put("key4","string2");

String json = new ObjectMapper().writeValueAsString(map);
System.out.println(json);

Dépendances Maven pour Jackson :

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.5.3</version>
    <scope>compile</scope>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.5.3</version>
    <scope>compile</scope>
</dependency>

Si vous utilisez JSONObject bibliothèque, vous pouvez convertir la carte de JSON comme suit:

Map<String, Object> map = new HashMap<>();
// Convert a map having list of values.
String[] value1 = new String[] { "value11", "value12", "value13" };
String[] value2 = new String[] { "value21", "value22", "value23" };
map.put("key1", value1);
map.put("key2", value2);

JSONObject json = new JSONObject(map);
System.out.println(json);

Dépendances Maven pour JSONObject :

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20140107</version>
</dependency>

J'espère que cela aidera. Heureux de codage.

Vous pouvez simplement énumérer la carte et ajouter les paires clé-valeur au JSONObject

Méthode :

private JSONObject getJsonFromMap(Map<String, Object> map) throws JSONException {
    JSONObject jsonData = new JSONObject();
    for (String key : map.keySet()) {
        Object value = map.get(key);
        if (value instanceof Map<?, ?>) {
            value = getJsonFromMap((Map<String, Object>) value);
        }
        jsonData.put(key, value);
    }
    return jsonData;
}

Dans mon cas, je ne voulais aucune dépendance. En utilisant Java 8, vous pouvez obtenir JSON comme une chaîne aussi simple:

Map<String, Object> map = new HashMap<>();
map.put("key", "value");
map.put("key2", "value2");
String json = "{"+map.entrySet().stream()
    .map(e -> "\""+ e.getKey() + "\"" + ":\"" + String.valueOf(e.getValue()) + "\"")
    .collect(Collectors.joining(", "))+"}";

Underscore-la bibliothèque java peut convertir une carte de hachage ou une liste de tableaux en json et vice verse.

import com.github.underscore.lodash.U;
import java.util.*;

public class Main {

    public static void main(String[] args) {

        Map<String, Object> map = new LinkedHashMap<>();
        map.put("1", "a");
        map.put("2", "b");

        System.out.println(U.toJson(map));
        // {
        //    "1": "a",
        //    "2": "b"
        // }
    }
}

En retard à la fête mais voici mon GSON adhoc writer pour sérialiser hashmap. J'ai dû écrire une carte de paires clé-valeur en tant qu'attributs de chaîne json, attendez-vous à ce qu'un spécifique soit de type entier. Je ne voulais pas créer un wrapper JavaBean personnalisé pour ce simple cas d'utilisation.

La classe GSON JsonWriter est une classe de sérialiseur facile à utiliser contenant peu d'écrivains fortement typés.la valeur de() les fonctions.

// write Map as JSON document to http servlet response
Map<String,String> sd = DAO.getSD(123);
res.setContentType("application/json; charset=UTF-8");
res.setCharacterEncoding("UTF-8");
JsonWriter writer = new JsonWriter(new OutputStreamWriter(res.getOutputStream(), "UTF-8"));
writer.beginObject();
for(String key : sd.keySet()) {
    String val = sd.get(key);
    writer.name(key);
    if (key.equals("UniqueID") && val!=null)
        writer.value(Long.parseLong(val));
    else
        writer.value(val);
}
writer.endObject();
writer.close();

Si aucun des types personnalisés n'est nécessaire, je pourrais simplement utiliser la fonction toJson (). gson-2.2.4.la bibliothèque jar est un peu moins de 190 Ko sans dépendances brutales. Facile à utiliser sur n'importe quelle application de servlet personnalisée ou application autonome sans grandes intégrations de framework.

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

C'est généralement le travail d'une bibliothèque Json, vous ne devriez pas essayer de le faire vous-même. Toutes les bibliothèques json doivent implémenter ce que vous demandez, et vous pouvez trouver une liste de bibliothèques Java Json sur json.org, au bas de la page.

Si vous avez besoin de l'utiliser dans le code.

Gson gsone = new Gson();
JsonObject res = gsone.toJsonTree(sqlParams).getAsJsonObject();

J'ai trouvé un autre moyen de le gérer.

Map obj=new HashMap();    
obj.put("name","sonoo");    
obj.put("age",new Integer(27));    
obj.put("salary",new Double(600000));   
String jsonText = JSONValue.toJSONString(obj);  
System.out.print(jsonText);

J'espère que cela aide.

Merci.

Cette solution fonctionne avec des JSON complexes:

public Object toJSON(Object object) throws JSONException {
    if (object instanceof HashMap) {
        JSONObject json = new JSONObject();
        HashMap map = (HashMap) object;
        for (Object key : map.keySet()) {
            json.put(key.toString(), toJSON(map.get(key)));
        }
        return json;
    } else if (object instanceof Iterable) {
        JSONArray json = new JSONArray();
        for (Object value : ((Iterable) object)) {
            json.put(toJSON(value));
        }
        return json;
    }
    else {
        return object;
    }
}

Mieux vaut être en retard que jamais. J'ai utilisé GSON pour convertir la liste de HashMap en chaîne si vous souhaitez avoir une liste sérialisée.

List<HashMap<String, String>> list = new ArrayList<>();
HashMap<String,String> hashMap = new HashMap<>();
hashMap.add("key", "value");
hashMap.add("key", "value");
hashMap.add("key", "value");
list.add(hashMap);

String json = new Gson().toJson(list);

Ce json produit [{"key":"value","key":"value","key":"value"}]

Pour ceux qui utilisent org.json.simple.JSONObject, vous pouvez convertir la carte en chaîne Json et l'analyser pour obtenir le JSONObject.

JSONObject object = (JSONObject) new JSONParser().parse(JSONObject.toJSONString(map));

Si vous n'avez pas vraiment besoin de HashMap, vous pouvez faire quelque chose comme ça:

String jsonString = new JSONObject() {{
  put("firstName", user.firstName);
  put("lastName", user.lastName);
}}.toString();

Sortie:

{
  "firstName": "John",
  "lastName": "Doe"
}

Nous utilisons Gson.

Gson gson = new Gson();
Type gsonType = new TypeToken<HashMap>(){}.getType();
String gsonString = gson.toJson(elements,gsonType);

Voici ma solution à une seule ligne avec GSON:

myObject = new Gson().fromJson(new Gson().toJson(myHashMap), MyClass.class);

J'utilise Alibaba fastjson, facile et simple:

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>VERSION_CODE</version>
</dependency>

Et importer:

import com.alibaba.fastjson.JSON;

Puis:

String text = JSON.toJSONString(obj); // serialize
VO vo = JSON.parseObject("{...}", VO.class); //unserialize

Tout va bien.

Vous pouvez utiliser XStream - c'est vraiment pratique. Voir les exemples ici

package com.thoughtworks.xstream.json.test;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver;

public class WriteTest {

    public static void main(String[] args) {

      HashMap<String,String> map = new HashMap<String,String>();
      map.add("1", "a");
      map.add("2", "b");
      XStream xstream = new XStream(new JettisonMappedXmlDriver());

      System.out.println(xstream.toXML(map));       

    }

}

Si vous utilisez net.sf.json.JSONObject, vous ne trouverez pas de constructeur JSONObject(map) dedans. Vous devez utiliser la méthode public static JSONObject fromObject( Object object ). Cette méthode accepte les chaînes au format JSON, les Cartes, les DynaBeans et les JavaBeans.

JSONObject jsonObject = JSONObject.fromObject(myMap);

Si vous utilisez des objets complexes, il convient d'appliquer enableComplexMapKeySerialization(), comme indiqué dans https://stackoverflow.com/a/24635655/2914140 et https://stackoverflow.com/a/26374888/2914140.

Gson gson = new GsonBuilder().enableComplexMapKeySerialization().create();
Map<Point, String> original = new LinkedHashMap<Point, String>();
original.put(new Point(5, 6), "a");
original.put(new Point(8, 8), "b");
System.out.println(gson.toJson(original));

La sortie sera:

{
 "(5,6)": "a",
 "(8,8)": "b"
}

Pas besoin de bibliothèques d'analyse Gson ou JSON. Juste en utilisant new JSONObject(Map<String, JSONObject>).toString(), par exemple:

/**
 * convert target map to JSON string
 *
 * @param map the target map
 * @return JSON string of the map
 */
@NonNull public String toJson(@NonNull Map<String, Target> map) {
    final Map<String, JSONObject> flatMap = new HashMap<>();
    for (String key : map.keySet()) {
        try {
            flatMap.put(key, toJsonObject(map.get(key)));
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
    try {
        // 2 indentSpaces for pretty printing
        return new JSONObject(flatMap).toString(2);
    } catch (JSONException e) {
        e.printStackTrace();
        return "{}";
    }
}

    import org.json.JSONObject;

    HashMap<Object, Object> map = new HashMap<>();
    String[] list={"Grader","Participant"};
    String[] list1={"Assistant","intern"};
    map.put("TeachingAssistant",list);
    map.put("Writer",list1);
    JSONObject jsonObject = new JSONObject(map);
    System.out.printf(jsonObject.toString());

    // Result: {"TeachingAssistant":["Grader","Participant"],"Writer":["Assistant","intern"]}

Si vous utilisez JSR 374: API Java pour le traitement JSON ( javax json ) Cela semble faire l'affaire:

    JsonObjectBuilder job = Json.createObjectBuilder((Map<String, Object>) obj);
    JsonObject jsonObject = job.build();

Vous pouvez utiliser Gson. Cette bibliothèque fournit des méthodes simples pour convertir des objets Java en objets JSON et vice-versa.

Exemple:

GsonBuilder gb = new GsonBuilder();
Gson gson = gb.serializeNulls().create();
gson.toJson(object);

Vous pouvez utiliser un GsonBuilder lorsque vous devez définir des options de configuration autres que la valeur par défaut. Dans l'exemple ci-dessus, le processus de conversion sérialisera également les attributs null de l'objet.

Cependant, cette approche ne fonctionne que pour les types non génériques. Pour les types génériques, vous devez utiliser toJson (object, Type).

Plus informations sur Gson ici.

Rappelez-vous que l'objet doit implémenter l' Serializable interface.

Cela fonctionne pour moi :

import groovy.json.JsonBuilder
properties = new Properties()
properties.put("name", "zhangsan")

println new JsonBuilder(properties).toPrettyString()

Gson way pour des cartes et des listes un peu plus complexes en utilisant TypeToken.getParameterized méthode:

, Nous avons une carte qui ressemble à ceci:

Map<Long, List<NewFile>> map;

Nous obtenons le Type en utilisant la méthode getParameterized mentionnée ci-dessus comme ceci:

Type listOfNewFiles = TypeToken.getParameterized(ArrayList.class, NewFile.class).getType();
Type mapOfList = TypeToken.getParameterized(LinkedHashMap.class, Long.class, listOfNewFiles).getType();

, puis utiliser la Gson objet fromJson méthode comme ceci en utilisant le mapOfList objet comme ceci:

Map<Long, List<NewFile>> map = new Gson().fromJson(fileContent, mapOfList);

Mentionnés objet NewFile ressemble à ceci:

class NewFile
{
    private long id;
    private String fileName;

    public void setId(final long id)
    {
        this.id = id;
    }

    public void setFileName(final String fileName)
    {
        this.fileName = fileName;
    }
}

Le désérialisé JSON ressemble à ceci:

{
  "1": [
    {
      "id": 12232,
      "fileName": "test.html"
    },
    {
      "id": 12233,
      "fileName": "file.txt"
    },
    {
      "id": 12234,
      "fileName": "obj.json"
    }
  ],
 "2": [
    {
      "id": 122321,
      "fileName": "test2.html"
    },
    {
      "id": 122332,
      "fileName": "file2.txt"
    },
    {
      "id": 122343,
      "fileName": "obj2.json"
    }
  ]
}

J'ai rencontré un problème similaire lors de la désérialisation de la réponse à partir de commandes personnalisées dans selenium. La réponse était json, mais selenium traduit en interne cela en java.util.HashMap[Chaîne, Objet]

Si vous connaissez scala et utilisez l'API play pour JSON, vous pourriez en bénéficier:

import play.api.libs.json.{JsValue, Json}
import scala.collection.JavaConversions.mapAsScalaMap


object JsonParser {

  def parse(map: Map[String, Any]): JsValue = {
    val values = for((key, value) <- map) yield {
      value match {
        case m: java.util.Map[String, _] @unchecked => Json.obj(key -> parse(m.toMap))
        case m: Map[String, _] @unchecked => Json.obj(key -> parse(m))
        case int: Int => Json.obj(key -> int)
        case str: String => Json.obj(key -> str)
        case bool: Boolean => Json.obj(key -> bool)
      }
    }

    values.foldLeft(Json.obj())((temp, obj) => {
      temp.deepMerge(obj)
    })
  }
}

Petit code description:

Le code traverse récursivement le HashMap jusqu'à ce que les types de base (String, Integer, Boolean) soient trouvés. Ces types de base peuvent être directement enveloppé dans un JsObject. Lorsque la récursivité est dépliée, le deepmerge concatène les objets créés.

'@unchecked' prend en charge les avertissements d'effacement de type.

Convertissez d'abord tous vos objets en chaînes valides

HashMap<String, String> params = new HashMap<>();
params.put("arg1", "<b>some text</b>");
params.put("arg2", someObject.toString());

Puis insérez la carte entière dans une organisation.json.JSONObject

JSONObject postData = new JSONObject(params);

Maintenant, vous pouvez obtenir le JSON en appelant simplement le toString de l'objet

postData.toString()
//{"arg1":"<b>some text<\/b>" "arg2":"object output"}

Créer un nouveau JSONObject

JSONObject o = new JSONObject(postData.toString());

Ou en tant que tableau d'octets pour l'envoi via HTTP

postData.toString().getBytes("UTF-8");