Bagaimana mengkonversi hashmap ke objek JSON di Java

Bagaimana cara mengubah atau membuang hashmap ke objek JSON di Java, dan kembali mengonversi objek JSON ke string JSON?

Kamu bisa memakai:

new JSONObject(map);

Perhatian: Ini hanya akan berfungsi untuk aMap<String, String>!

Fungsi lain yang bisa Anda dapatkan dari dokumentasinya
http://stleary.github.io/JSON-java/index.html

Gson juga dapat digunakan untuk membuat serialisasi objek kompleks yang sewenang-wenang.

Inilah cara Anda menggunakannya:

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

Gsonakan secara otomatis mengonversi koleksi ke JSONarray. Gson dapat membuat serial bidang pribadi dan secara otomatis mengabaikan bidang sementara.

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

keluaran::

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

Anda juga dapat mencoba menggunakan GSON Google. GSON Google adalah perpustakaan terbaik yang tersedia untuk mengonversi Java Objects menjadi representasi JSON mereka.

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

Anda dapat mengonversi Mapuntuk JSONmenggunakan Jacksonsebagai berikut:

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

Ketergantungan Maven untuk 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>

Jika Anda menggunakan JSONObjectperpustakaan, Anda dapat mengonversi peta menjadi JSONsebagai berikut:

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

Ketergantungan Maven untuk JSONObject:

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

Semoga ini bisa membantu. Selamat coding.

Dalam kasus saya, saya tidak ingin ada ketergantungan. Menggunakan Java 8 Anda bisa mendapatkan JSON sebagai string ini sesederhana ini:

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

Anda bisa menghitung peta dan menambahkan pasangan nilai kunci ke JSONObject

Metode :

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

Pustaka underscore-java dapat mengonversi peta hash atau daftar larik menjadi json dan sebaliknya.

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

Terlambat ke pesta tetapi di sini adalah GSON saya penulis adhoc untuk membuat serial hashmap. Saya harus menulis peta pasangan kunci-nilai sebagai atribut string json, berharap satu spesifik menjadi tipe integer. Saya tidak ingin membuat pembungkus JavaBean khusus untuk penggunaan sederhana ini.

Kelas GSON JsonWriter mudah digunakan kelas serializer yang berisi beberapa fungsi writer.value () sangat diketik.

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

Jika tidak ada jenis kustom yang diperlukan, saya bisa menggunakan fungsi toJson () saja. perpustakaan gson-2.2.4.jar hanya di bawah 190KB tanpa ketergantungan brutal. Mudah digunakan pada aplikasi servlet khusus atau aplikasi mandiri tanpa integrasi kerangka besar.

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

Ini biasanya karya perpustakaan Json, Anda sebaiknya tidak mencoba melakukannya sendiri. Semua pustaka json harus mengimplementasikan apa yang Anda minta, dan Anda dapat menemukan daftar pustaka Java Json di json.org , di bagian bawah halaman.

Saya menemukan cara lain untuk menanganinya.

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

Semoga ini membantu.

Terima kasih.

Jika Anda perlu menggunakannya dalam kode.

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

Bagi yang menggunakan org.json.simple.JSONObject, Anda bisa mengonversi peta menjadi Json String dan menguraikannya untuk mendapatkan JSONObject.

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

Lebih baik terlambat daripada tidak pernah sama sekali. Saya menggunakan GSON untuk mengonversi daftar HashMap ke string jika jika Anda ingin memiliki daftar serial.

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

Ini jsonmenghasilkan[{"key":"value","key":"value","key":"value"}]

Di sini solusi single-line saya dengan GSON:

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

Solusi ini bekerja dengan JSONs kompleks:

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

kami menggunakan Gson.

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

Anda dapat menggunakan XStream - ini sangat berguna. Lihat contoh di sini

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

    }

}

Jika Anda menggunakan net.sf.json.JSONObjectmaka Anda tidak akan menemukan JSONObject(map)konstruktor di dalamnya. Anda harus menggunakan public static JSONObject fromObject( Object object )metode ini. Metode ini menerima string berformat JSON, Maps, DynaBeans dan JavaBeans.

JSONObject jsonObject = JSONObject.fromObject(myMap);

Jika Anda menggunakan objek yang kompleks, Anda harus menerapkan enableComplexMapKeySerialization () , seperti yang dinyatakan dalam https://stackoverflow.com/a/24635655/2914140 dan 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));

Output akan menjadi:

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

Tidak perlu parsing pustaka Gson atau JSON. Hanya menggunakan new JSONObject(Map<String, JSONObject>).toString(), misalnya:

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

Jika Anda tidak benar-benar membutuhkan HashMap maka Anda dapat melakukan sesuatu seperti itu:

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

Keluaran:

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

Saya menggunakan fastjson Alibaba, mudah dan sederhana:

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

dan impor:

import com.alibaba.fastjson.JSON;

Kemudian:

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

Semuanya baik-baik saja.

Jika Anda menggunakan JSR 374: Java API untuk JSON Processing (javax json) Ini sepertinya melakukan trik:

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

Anda dapat menggunakan Gson . Pustaka ini menyediakan metode sederhana untuk mengonversi objek Java ke objek JSON dan sebaliknya.

Contoh:

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

Anda dapat menggunakan GsonBuilder saat Anda perlu mengatur opsi konfigurasi selain yang standar. Pada contoh di atas, proses konversi juga akan membuat cerita bersambung atribut nol dari objek.

Namun, pendekatan ini hanya berfungsi untuk tipe non-generik. Untuk tipe generik Anda perlu menggunakan toJson (objek, Type).

Informasi lebih lanjut tentang Gson di sini .

Ingat bahwa objek harus mengimplementasikan antarmuka Serializable .

ini bekerja untuk saya:

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

println new JsonBuilder(properties).toPrettyString()

Jalan gson untuk peta dan daftar sedikit lebih kompleks menggunakan metode TypeToken.getParameterized :

Kami memiliki peta yang terlihat seperti ini:

Map<Long, List<NewFile>> map;

Kami mendapatkan Type menggunakan metode getParameter yang disebutkan di atas seperti ini:

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

Dan kemudian gunakan objek Gson dari metode Json seperti ini menggunakan objek mapOfList seperti ini:

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

Objek yang disebutkan NewFile terlihat seperti ini:

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

JSON deserialized terlihat seperti ini:

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

Saya menghadapi masalah yang sama ketika deserializing Respon dari perintah khusus di selenium. Responsnya adalah json, tetapi selenium menerjemahkannya secara internal ke java.util.HashMap [String, Object]

Jika Anda terbiasa dengan scala dan menggunakan play-API untuk JSON, Anda dapat mengambil manfaat dari ini:

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

Deskripsi kode kecil:

Kode secara rekursif melintasi HashMap hingga tipe dasar (String, Integer, Boolean) ditemukan. Tipe dasar ini dapat langsung dibungkus menjadi JsObject. Ketika rekursi dibuka, deepmerge menggabungkan objek yang dibuat.

'@blocked' menangani peringatan penghapusan tipe.

Konversikan terlebih dahulu semua objek Anda menjadi String yang valid

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

Kemudian masukkan seluruh peta ke dalam org.json.JSONObject

JSONObject postData = new JSONObject(params);

Sekarang Anda bisa mendapatkan JSON hanya dengan memanggil toString objek

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

Buat JSONObject baru

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

Atau sebagai array byte untuk mengirim melalui HTTP

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