Comment convertir hashmap en objet JSON en Java
Comment convertir ou convertir un hashmap en objet JSON en Java et convertir à nouveau un objet JSON en chaîne JSON?
Vous pouvez utiliser:
new JSONObject(map);
Attention: Ceci ne fonctionnera que pour un Map<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);
Gson convertira automatiquement les collections en tableaux JSON. Gson peut sérialiser les 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) );
sortie::
JSON: {
"age": 32,
"name": "Mars",
"city": "NY"
}
Vous pouvez également essayer d'utiliser le GSON de Google. Le GSON de Google est la meilleure bibliothèque disponible pour convertir les objets Java en leur représentation JSON.
Vous pouvez convertir Map en JSON en utilisant 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 la bibliothèque JSONObject, vous pouvez convertir la carte en 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. Bonne codage.
Vous pouvez simplement énumérer la carte et ajouter les paires clé-valeur à l'objet 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;
}
En retard pour la fête mais voici mon GSON écrivain adhoc pour la sérialisation de hashmap. Je devais écrire un mappage de paires clé-valeur en tant qu'attributs de chaîne json, attendez-vous à ce qu'un type spécifique soit de type entier. Je ne voulais pas créer un wrapper JavaBean personnalisé pour ce cas d'utilisation simple.
La classe GSON JsonWriter est facile à utiliser. Elle contient 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 ne sont nécessaires, je pourrais simplement utiliser la fonction toJson (). La bibliothèque gson-2.2.4.jar ne dépasse pas 190 Ko, sans aucune dépendance brutale. 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 typiquement 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 JSON Java 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.
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 que cela:
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(", "))+"}";
Pour ceux qui utilisent org.json.simple.JSONObject, vous pouvez convertir la carte en Json String et l’analyser pour obtenir JSONObject.
JSONObject object = (JSONObject) new JSONParser().parse(JSONObject.toJSONString(map));
Voici ma solution mono-ligne avec GSON:
myObject = new Gson().fromJson(new Gson().toJson(myHashMap), MyClass.class);
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 avez besoin de l'utiliser dans le code.
Gson gsone = new Gson();
JsonObject res = gsone.toJsonTree(sqlParams).getAsJsonObject();
Underscore-Java library peut convertir une carte de hachage ou une liste de tableaux en json et vice versa.
Exemple de code:
import com.github.underscore.lodash.U;
import Java.util.*;
public class Main {
public static void main(String[] args) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("1", "a");
map.put("2", "b");
System.out.println(U.toJson(map));
// {
// "1": "a",
// "2": "b"
// }
}
}
Pas besoin de bibliothèques d'analyse syntaxique 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 "{}";
}
}
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;
}
}
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"]}
cela fonctionne pour moi:
import groovy.json.JsonBuilder
properties = new Properties()
properties.put("name", "zhangsan")
println new JsonBuilder(properties).toPrettyString()
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"
}
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.
Vous pouvez utiliser Gson . Cette bibliothèque fournit des méthodes simples pour convertir des objets Java en objets JSON et inversement.
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érialisera é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.
Si vous utilisez des objets complexes, appliquez 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"
}
Mieux vaut être en retard que jamais. J'ai utiliséGSONpour convertir une 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);
Cette json produit [{"key":"value","key":"value","key":"value"}]
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 cela en interne en Java.util.HashMap [String, Object]
Si vous connaissez scala et utilisez la play-API for JSON, vous pouvez en tirer avantage:
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'à trouver les types de base (String, Integer, Boolean). Ces types de base peuvent être directement intégrés dans un JsObject. Lorsque la récursion est déployée, deepmerge concatène les objets créés.
@unchecked prend en charge les avertissements d'effacement de type.