Come convertire hashmap in oggetto JSON in Java

Come convertire o trasmettere hashmap all'oggetto JSON in Java e convertire nuovamente l'oggetto JSON in stringa JSON?

Puoi usare:

new JSONObject(map);

Attenzione: questo funzionerà solo per aMap<String, String>!

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

Gsonconvertirà automaticamente le raccolte in JSONarray. Gson può serializzare campi privati ​​e ignora automaticamente i campi transitori.

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

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/

È possibile convertire Mapin JSONusando Jacksoncome segue:

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

Dipendenze Maven per 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>

Se si utilizza la JSONObjectlibreria, è possibile convertire la mappa JSONnel modo seguente:

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

Dipendenze Maven per JSONObject:

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

Spero che questo possa aiutare. Buona codifica.

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

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

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

Metodo :

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 libreria Underscore-java può convertire la mappa hash o l'elenco di array in json e viceversa.

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

In ritardo alla festa, ma ecco il mio GSON scrittore ad hoc per serializzare l'hashmap. Ho dovuto scrivere una mappa di coppie chiave-valore come attributi di stringa json, aspettandomi che uno specifico fosse di tipo intero. Non volevo creare un wrapper JavaBean personalizzato per questo semplice esempio di utilizzo.

La classe GSON JsonWriter è una classe serializzatore facile da usare che contiene alcune funzioni writer.value () fortemente tipizzate.

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

Se non fosse necessario nessuno dei tipi personalizzati, avrei potuto usare la funzione toJson (). La libreria gson-2.2.4.jar ha poco meno di 190 KB senza alcuna brutale dipendenza. Facile da usare su qualsiasi app servlet personalizzata o applicazione standalone senza grandi integrazioni del framework.

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

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

Ho trovato un altro modo di 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.

Se è necessario utilizzarlo nel codice.

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

Per quelli che usano org.json.simple.JSONObject, puoi convertire la mappa in Json String e analizzarla per ottenere il JSONObject.

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

Meglio essere in ritardo che mai. Ho usato GSON per convertire l'elenco di HashMap in stringa se nel caso in cui si desidera disporre di un elenco serializzato.

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

Questo jsonproduce[{"key":"value","key":"value","key":"value"}]

Ecco la mia soluzione a linea singola con GSON:

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

Questa soluzione funziona con JSON complessi:

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

usiamo Gson.

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

Puoi usare XStream: è davvero utile. 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<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));       

    }

}

Se stai usando net.sf.json.JSONObject, non troverai un JSONObject(map)costruttore in esso. Devi usare il public static JSONObject fromObject( Object object )metodo Questo metodo accetta stringhe in formato JSON, Maps, DynaBeans e JavaBeans.

JSONObject jsonObject = JSONObject.fromObject(myMap);

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

L'output sarà:

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

Non sono necessarie librerie di analisi Gson o JSON. Basta usare new JSONObject(Map<String, JSONObject>).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<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"]}

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

Sto usando Alibaba Fastjson, facile e semplice:

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

e importazione:

import com.alibaba.fastjson.JSON;

Poi:

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

Va tutto bene.

Se stai usando JSR 374: API Java per l'elaborazione JSON (javax json) Questo sembra fare il trucco:

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

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

È possibile utilizzare un GsonBuilder quando è necessario impostare opzioni di configurazione diverse da quelle predefinite. Nell'esempio sopra, il processo di conversione serializzerà anche gli attributi null dall'oggetto.

Tuttavia, questo approccio funziona solo per tipi non generici. Per i tipi generici è necessario utilizzare toJson (oggetto, Tipo).

Maggiori informazioni su Gson qui .

Ricordare che l'oggetto deve implementare l' interfaccia Serializable .

questo funziona per me:

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

println new JsonBuilder(properties).toPrettyString()

Modo Gson per mappe ed elenchi un po 'più complessi usando il metodo TypeToken.getParameterized :

Abbiamo una mappa che assomiglia a questa:

Map<Long, List<NewFile>> map;

Otteniamo il Tipo usando il metodo getParameterized sopra citato come questo:

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

E quindi usa l'oggetto Gson dal metodo Json in questo modo usando l' oggetto mapOfList in questo modo:

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

L'oggetto menzionato NewFile è simile al seguente:

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

Il JSON deserializzato si presenta così:

{
  "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"
    }
  ]
}

Ho riscontrato un problema simile durante la deserializzazione della risposta dai comandi personalizzati in selenio. La risposta è stata json, ma il selenio lo traduce internamente in java.util.HashMap [String, Object]

Se hai familiarità con Scala e usi l'API di riproduzione per JSON, potresti trarne vantaggio:

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

Piccola descrizione del codice:

Il codice attraversa ricorsivamente l'HashMap fino a trovare i tipi di base (String, Integer, Boolean). Questi tipi di base possono essere inseriti direttamente in un oggetto JsObject. Quando la ricorsione è aperta, il deepmerge concatena gli oggetti creati.

'@unchecked' si occupa degli avvisi di cancellazione del tipo.

Prima converti tutti i tuoi oggetti in stringhe valide

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

Quindi inserire l'intera mappa in un org.json.JSONObject

JSONObject postData = new JSONObject(params);

Ora puoi ottenere il JSON semplicemente chiamando l'oggetto a String

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

Crea un nuovo JSONObject

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

O come array di byte per l'invio tramite HTTP

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