Come convertire hashmap in object JSON in Java

Come convertire o eseguire il cast di hashmap in JSON in Java e convertire nuovamente l’object JSON in stringa JSON?

Puoi usare:

new JSONObject(map); 

Attenzione: funzionerà solo su Map!

Altre funzioni che puoi ottenere dalla sua documentazione
http://stleary.github.io/JSON-java/index.html

Gson può anche essere usato per serializzare oggetti arbitrariamente complessi.

Ecco come lo usi:

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

Gson convertirà automaticamente le raccolte in array JSON . Gson può serializzare i campi privati ​​e ignora automaticamente i campi transitori.

Esempio usando json

 Map data = new HashMap(); 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) ); 

produzione::

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

Puoi anche provare a utilizzare GSON di Google. GSON di Google è la migliore libreria disponibile per convertire oggetti Java nella loro rappresentazione JSON.

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

Puoi convertire Map in JSON usando Jackson come segue:

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

Dipendenze di Maven per Jackson :

  com.fasterxml.jackson.core jackson-core 2.5.3 compile   com.fasterxml.jackson.core jackson-databind 2.5.3 compile  

Se si utilizza la libreria JSONObject , è ansible convertire la mappa in JSON come segue:

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

Dipendenze Maven per JSONObject :

  org.json json 20140107  

Spero che questo ti sia d’aiuto. Buona programmazione.

In ritardo per la festa, ma qui è il mio autore ad hoc di GSON per serializzare hashmap. Ho dovuto scrivere la mappa delle coppie chiave-valore come attributi stringa json, aspetto che uno specifico sia un tipo intero. Non volevo creare un wrapper JavaBean personalizzato per questo semplice caso d’uso.

La class JSONWriter di GSON è una class serializzatore facile da usare che contiene alcune funzioni writer.value () fortemente tipizzate.

 // write Map as JSON document to http servlet response Map 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(); 

Se nessuno dei tipi personalizzati è necessario, potrei semplicemente usare la funzione json (). La libreria gson-2.2.4.jar è appena sotto 190 KB senza alcuna dipendenza brutale. Facile da usare su qualsiasi app servlet personalizzata o applicazione standalone senza grandi integrazioni di framework.

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

Questo è tipicamente il lavoro di una libreria Json, non dovresti provare a farlo da solo. Tutte le librerie JSON dovrebbero implementare quello che stai chiedendo, e puoi trovare un elenco di librerie Java Json su json.org , in fondo alla pagina.

Ho trovato un altro modo per gestirlo.

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

Spero che questo ti aiuti.

Grazie.

Puoi semplicemente enumerare la mappa e aggiungere le coppie chiave-valore a JSONObject

Metodo :

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

Puoi usare XStream: è davvero a portata di mano. Vedi gli esempi qui

 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 map = new HashMap(); map.add("1", "a"); map.add("2", "b"); XStream xstream = new XStream(new JettisonMappedXmlDriver()); System.out.println(xstream.toXML(map)); } } 

Se si utilizza net.sf.json.JSONObject , non si troverà un JSONObject(map) al suo interno. Devi usare il metodo public static JSONObject fromObject( Object object ) . Questo metodo accetta stringhe formattate JSON, Maps, DynaBeans e JavaBeans.

JSONObject jsonObject = JSONObject.fromObject(myMap);

Se hai bisogno di usarlo nel codice.

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

Nel mio caso non volevo dipendenze. Usando Java 8 puoi ottenere JSON come una stringa così semplice:

 Map 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(", "))+"}"; 

Ecco la mia soluzione single-line con GSON:

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

Nessuna necessità per le librerie di analisi GSON o JSON. Basta usare il new JSONObject(Map).toString() , ad esempio:

 /** * convert target map to JSON string * * @param map the target map * @return JSON string of the map */ @NonNull public String toJson(@NonNull Map map) { final Map 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 "{}"; } } 

Per coloro che utilizzano org.json.simple.JSONObject , è ansible convertire la mappa in JSON String e analizzarla per ottenere JSONObject .

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

La libreria Underscore-java può convertire la mappa hash o l’array in json e viceversa.

Esempio di codice:

 import com.github.underscore.lodash.U; import java.util.*; public class Main { public static void main(String[] args) { Map map = new HashMap(); map.put("1", "a"); map.put("2", "b"); System.out.println(U.toJson(map)); // { // "1": "a", // "2": "b" // } } } 

Ho affrontato un problema simile quando deserializza la risposta dai comandi personalizzati nel selenium. La risposta è stata JSON, ma il selenium internamente lo traduce in una java.util.HashMap [String, Object]

Se hai familiarità con scala e usi l’API di gioco per JSON, potresti trarre vantaggio da questo:

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

Descrizione del codice piccolo:

Il codice attraversa in modo ricorsivo attraverso HashMap fino a quando vengono trovati i tipi di base (String, Integer, Boolean). Questi tipi di base possono essere inseriti direttamente in JsObject. Quando la ricorsione è dispiegata, l’approfondimento concatena gli oggetti creati.

‘@unchecked’ si occupa degli avvisi di cancellazione del tipo.

Puoi usare Gson . Questa libreria fornisce metodi semplici per convertire oggetti Java in oggetti JSON e viceversa.

Esempio:

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

È ansible utilizzare GsonBuilder quando è necessario impostare le opzioni di configurazione diverse da quelle predefinite. Nell’esempio precedente, il processo di conversione serializzerà anche attributi nulli da object.

Tuttavia, questo approccio funziona solo per tipi non generici. Per i tipi generici devi usare toJson (object, Type).

Maggiori informazioni su Gson qui .

Ricorda che l’object deve implementare l’interfaccia Serializable .

Se si utilizzano oggetti complessi, è necessario applicare enableComplexMapKeySerialization () , come indicato in https://stackoverflow.com/a/24635655/2914140 e https://stackoverflow.com/a/26374888/2914140 .

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

L’output sarà:

 { "(5,6)": "a", "(8,8)": "b" } 
  import org.json.JSONObject; HashMap 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"]} 

Usando Gson, puoi ottenere una stringa JSON da un object attraverso una linea come segue:

 public static String convertUsingGson(HashMap studentGrades) { Gson gson = new Gson(); String studentGradesJson = gson.toJson(studentGrades); return studentGradesJson; } 

Puoi farlo anche con Jackson, includi solo queste 3 librerie: annotazioni di jackson, jackson-core e jackson-databind , e qui vai:

 public static String convertUsingJackson(HashMap studentGrades) { String studentGradesJson = ""; try { ObjectMapper mapper = new ObjectMapper(); studentGradesJson = mapper.writeValueAsString(studentGrades); } catch(Exception ex) { System.out.println("Error while converting Student Grades map to Json"); ex.printStackTrace(); } return studentJson; } 

Riferimento: convertire l’object Java in JSON

Se non hai davvero bisogno di HashMap, puoi fare qualcosa del genere:

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

Produzione:

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