Jawaban:
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
Map
ke dalam JSONObject
tapi bagaimana Anda bisa mendapatkan peta ini dari JSONObject?
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);
Gson
akan secara otomatis mengonversi koleksi ke JSON
array. 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.
2
dilakukan di json.toString(
2`)
Anda dapat mengonversi Map
untuk JSON
menggunakan Jackson
sebagai 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 JSONObject
perpustakaan, Anda dapat mengonversi peta menjadi JSON
sebagai 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(", "))+"}";
"
, ini rusak
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);
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 json
menghasilkan[{"key":"value","key":"value","key":"value"}]
Gson
.
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.JSONObject
maka 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"
}
HashMap
, dan ini tidak menjawab itu.
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.
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");