So konvertieren Sie Hashmap in JSON-Objekt in Java

Wie konvertiere oder wandle ich eine Hashmap in ein JSON-Objekt in Java und konvertiere ein JSON-Objekt erneut in eine JSON-Zeichenfolge?

Sie können verwenden:

new JSONObject(map);

Achtung: Dies funktioniert nur für aMap<String, String>!

Weitere Funktionen finden Sie in der Dokumentation
http://stleary.github.io/JSON-java/index.html

Gson kann auch verwendet werden, um beliebig komplexe Objekte zu serialisieren.

So verwenden Sie es:

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

Gsonkonvertiert automatisch Sammlungen in JSONArrays. Gson kann private Felder serialisieren und transiente Felder automatisch ignorieren.

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

Ausgabe::

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

Sie können auch versuchen, Googles GSON zu verwenden. Googles GSON ist die beste verfügbare Bibliothek, um Java-Objekte in ihre JSON-Darstellung zu konvertieren.

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

Sie können konvertieren Mapzu JSONverwenden , Jacksonwie folgt:

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

Maven-Abhängigkeiten für 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>

Wenn Sie eine JSONObjectBibliothek verwenden, können Sie die Karte JSONwie folgt konvertieren :

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

Maven-Abhängigkeiten für JSONObject:

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

Hoffe das wird helfen. Viel Spaß beim Codieren.

In meinem Fall wollte ich keine Abhängigkeiten. Mit Java 8 können Sie JSON als Zeichenfolge so einfach erhalten:

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

Sie können einfach die Map auflisten und die Schlüssel-Wert-Paare zum JSONObject hinzufügen

Methode :

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

Die Underscore-Java- Bibliothek kann die Hash-Map oder Array-Liste in JSON konvertieren und umgekehrt.

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

Spät zur Party, aber hier ist mein GSON- Ad-hoc-Autor für die Serialisierung von Hashmap. Ich musste eine Zuordnung von Schlüssel-Wert-Paaren als JSON-Zeichenfolgenattribute schreiben. Erwarten Sie, dass eine bestimmte Ganzzahl vom Typ ist. Ich wollte keinen benutzerdefinierten JavaBean-Wrapper für diesen einfachen Anwendungsfall erstellen.

Die GSON JsonWriter-Klasse ist eine einfach zu verwendende Serializer-Klasse, die nur wenige stark typisierte writer.value () -Funktionen enthält.

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

Wenn keiner der benutzerdefinierten Typen benötigt wird, hätte ich einfach die Funktion toJson () verwenden können. Die gson-2.2.4.jar-Bibliothek ist knapp 190 KB groß und weist keine brutalen Abhängigkeiten auf. Einfache Verwendung in jeder benutzerdefinierten Servlet-App oder eigenständigen Anwendung ohne große Framework-Integrationen.

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

Dies ist normalerweise die Arbeit einer Json-Bibliothek. Sie sollten nicht versuchen, dies selbst zu tun. Alle JSON-Bibliotheken sollten das implementieren, wonach Sie fragen. Eine Liste der Java-Json-Bibliotheken finden Sie auf json.org am Ende der Seite.

Ich habe einen anderen Weg gefunden, damit umzugehen.

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

Hoffe das hilft.

Vielen Dank.

Wenn Sie es brauchen, verwenden Sie es im Code.

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

Für diejenigen org.json.simple.JSONObject, die verwenden , können Sie die Map in Json String konvertieren und analysieren, um die zu erhalten JSONObject.

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

Komm lieber zu spät als nie. Ich habe GSON verwendet , um die Liste von HashMap in einen String zu konvertieren, falls Sie eine serialisierte Liste haben möchten.

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

Dies jsonerzeugt[{"key":"value","key":"value","key":"value"}]

Hier meine einzeilige Lösung mit GSON:

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

Diese Lösung funktioniert mit komplexen JSONs:

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

Wir benutzen Gson.

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

Sie können XStream verwenden - es ist wirklich praktisch. Siehe die Beispiele hier

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

    }

}

Wenn Sie verwenden, finden net.sf.json.JSONObjectSie keinen JSONObject(map)Konstruktor darin. Sie müssen die public static JSONObject fromObject( Object object )Methode verwenden. Diese Methode akzeptiert JSON-formatierte Zeichenfolgen, Maps, DynaBeans und JavaBeans.

JSONObject jsonObject = JSONObject.fromObject(myMap);

Wenn Sie komplexe Objekte verwenden, sollten Sie enableComplexMapKeySerialization () anwenden , wie unter https://stackoverflow.com/a/24635655/2914140 und https://stackoverflow.com/a/26374888/2914140 angegeben .

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

Ausgabe wird sein:

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

Keine Notwendigkeit für Gson- oder JSON-Parsing-Bibliotheken. Nur mit new JSONObject(Map<String, JSONObject>).toString(), zB:

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

Wenn Sie HashMap nicht wirklich benötigen, können Sie Folgendes tun:

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

Ausgabe:

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

Ich benutze Alibaba fastjson, leicht und einfach:

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

und importieren:

import com.alibaba.fastjson.JSON;

Dann:

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

Alles ist ok.

Wenn Sie JSR 374 verwenden: Java-API für die JSON-Verarbeitung (javax json) Dies scheint den Trick zu tun:

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

Sie können Gson verwenden . Diese Bibliothek bietet einfache Methoden zum Konvertieren von Java-Objekten in JSON-Objekte und umgekehrt.

Beispiel:

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

Sie können einen GsonBuilder verwenden, wenn Sie andere als die Standardkonfigurationsoptionen festlegen müssen. Im obigen Beispiel serialisiert der Konvertierungsprozess auch Nullattribute aus dem Objekt.

Dieser Ansatz funktioniert jedoch nur für nicht generische Typen. Für generische Typen müssen Sie toJson (Objekt, Typ) verwenden.

Weitere Informationen zu Gson hier .

Denken Sie daran, dass das Objekt die serialisierbare Schnittstelle implementieren muss .

das funktioniert bei mir:

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

println new JsonBuilder(properties).toPrettyString()

Gson Weg für etwas komplexere Karten und Listen mit der TypeToken.getParameterized- Methode:

Wir haben eine Karte, die so aussieht:

Map<Long, List<NewFile>> map;

Wir erhalten den Typ mit der oben genannten Methode getParameterized wie folgt :

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

Verwenden Sie dann die Methode Gson object fromJson wie folgt , indem Sie das Objekt mapOfList wie folgt verwenden :

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

Das erwähnte Objekt NewFile sieht folgendermaßen aus:

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

Der deserialisierte JSON sieht folgendermaßen aus:

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

Ich hatte ein ähnliches Problem beim Deserialisieren der Antwort von benutzerdefinierten Befehlen in Selen. Die Antwort war json, aber Selen übersetzt dies intern in eine java.util.HashMap [String, Object]

Wenn Sie mit Scala vertraut sind und die Play-API für JSON verwenden, können Sie davon profitieren:

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

Kleine Codebeschreibung:

Der Code durchläuft rekursiv die HashMap, bis Basistypen (String, Integer, Boolean) gefunden werden. Diese Grundtypen können direkt in ein JsObject eingeschlossen werden. Wenn die Rekursion entfaltet wird, verkettet der Deepmerge die erstellten Objekte.

'@unchecked' kümmert sich um Löschwarnungen.

Konvertieren Sie zuerst alle Ihre Objekte in gültige Zeichenfolgen

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

Fügen Sie dann die gesamte Map in ein org.json.JSONObject ein

JSONObject postData = new JSONObject(params);

Jetzt können Sie den JSON erhalten, indem Sie einfach den toString des Objekts aufrufen

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

Erstellen Sie ein neues JSONObject

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

Oder als Byte-Array zum Senden über HTTP

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