Comment convertir un hashmap en objet JSON en Java

Comment convertir ou convertir une table de hachage en objet JSON en Java, et à nouveau convertir l'objet JSON en chaîne JSON?

Vous pouvez utiliser:

new JSONObject(map);

Attention: cela ne fonctionnera queMap<String, String>!

Autres fonctions que vous pouvez obtenir à partir de sa documentation
http://stleary.github.io/JSON-java/index.html

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

Voici comment vous l'utilisez:

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

Gsonconvertira automatiquement les collections en JSONtableaux. Gson peut sérialiser des champs privés et ignore automatiquement les champs transitoires.

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

production::

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

Vous pouvez également essayer d'utiliser GSON de Google.Le 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 Mapen JSONutilisant Jacksoncomme 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 une JSONObjectbibliothèque, vous pouvez convertir la carte JSONcomme 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 vous aidera. Codage heureux.

Dans mon cas, je ne voulais pas de dépendances. En utilisant Java 8, vous pouvez obtenir JSON sous forme de 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(", "))+"}";

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

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

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"
        // }
    }
}

À la fin de la partie , mais voici mon GSON écrivain adhoc pour sérialisation hashmap. J'ai dû écrire une carte de paires clé-valeur en tant qu'attributs de chaîne json, s'attendre à ce qu'un spécifique soit de type entier. Je ne voulais pas créer de wrapper JavaBean personnalisé pour cette simple utilisation.

La classe GSON JsonWriter est une classe sérialiseur facile à utiliser contenant peu de fonctions writer.value () fortement typées.

// 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'était nécessaire, j'aurais pu simplement utiliser la fonction toJson (). La bibliothèque gson-2.2.4.jar fait 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 des bibliothèques Java Json sur json.org , au bas de la page.

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 t'aides.

Merci.

Si vous en avez besoin, utilisez-le dans le code.

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

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

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

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

Cela jsonproduit[{"key":"value","key":"value","key":"value"}]

Voici ma solution monoligne avec GSON:

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

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

nous utilisons Gson.

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

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.JSONObjectvous ne trouverez pas de JSONObject(map)constructeur dedans. Vous devez utiliser la public static JSONObject fromObject( Object object )méthode. Cette méthode accepte les chaînes au format JSON, Maps, DynaBeans et JavaBeans.

JSONObject jsonObject = JSONObject.fromObject(myMap);

Si vous utilisez des objets complexes, vous devez 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. En utilisant simplement 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 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();

Production:

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

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;

Ensuite:

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

Tout va bien.

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 celles par défaut. Dans l'exemple ci-dessus, le processus de conversion sérialise également les attributs nuls 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 (objet, Type).

Plus d'informations sur Gson ici .

N'oubliez pas que l'objet doit implémenter l' interface Serializable .

cela fonctionne pour moi:

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

println new JsonBuilder(properties).toPrettyString()

Façon Gson pour des cartes et des listes un peu plus complexes en utilisant la méthode TypeToken.getParameterized :

Nous avons une carte qui ressemble à ceci:

Map<Long, List<NewFile>> map;

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

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

Et puis utilisez l'objet Gson fromJson méthode comme ceci en utilisant l' objet mapOfList comme ceci:

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

L'objet mentionné 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 JSON désérialisé 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 des commandes personnalisées en sélénium. La réponse était json, mais le sélénium traduit cela en interne en java.util.HashMap [String, Object]

Si vous êtes familier avec 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)
    })
  }
}

Description du petit code:

Le code parcourt 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és dans un JsObject. Lorsque la récursivité est dépliée, la fusion profonde 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());

Ensuite, insérez la carte entière dans un org.json.JSONObject

JSONObject postData = new JSONObject(params);

Vous pouvez maintenant obtenir le JSON en appelant simplement 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 comme un tableau d'octets pour l'envoi via HTTP

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