Cách chuyển đổi hashmap thành đối tượng JSON trong Java

Làm cách nào để chuyển đổi hoặc truyền hashmap thành đối tượng JSON trong Java và một lần nữa chuyển đổi đối tượng JSON thành chuỗi JSON?

Bạn có thể dùng:

new JSONObject(map);

Thận trọng: Điều này sẽ chỉ làm việc cho mộtMap<String, String>!

Các chức năng khác bạn có thể nhận được từ tài liệu của mình
http://stleary.github.io/JSON-java/index.html

Gson cũng có thể được sử dụng để tuần tự hóa các đối tượng phức tạp tùy ý.

Đây là cách bạn sử dụng nó:

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

Gsonsẽ tự động chuyển đổi các bộ sưu tập thành JSONmảng. Gson có thể tuần tự hóa các trường riêng và tự động bỏ qua các trường tạm thời.

Ví dụ sử dụng 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) );

đầu ra ::

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

Bạn cũng có thể thử sử dụng GSON của Google. GSON của Google là thư viện tốt nhất hiện có để chuyển đổi Đối tượng Java thành biểu diễn JSON của họ.

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

Bạn có thể chuyển đổi Mapsang JSONsử dụng Jacksonnhư sau:

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

Phụ thuộc Maven cho 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>

Nếu bạn đang sử dụng JSONObjectthư viện, bạn có thể chuyển đổi bản đồ thành JSONnhư sau:

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

Phụ thuộc Maven cho JSONObject:

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

Hy vọng điều này sẽ giúp. Chúc mừng mã hóa.

Trong trường hợp của tôi, tôi không muốn có bất kỳ sự phụ thuộc nào. Sử dụng Java 8, bạn có thể nhận JSON dưới dạng một chuỗi đơn giản:

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

Bạn chỉ có thể liệt kê bản đồ và thêm các cặp khóa-giá trị vào JSONObject

Phương pháp :

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

Thư viện gạch dưới-java có thể chuyển đổi bản đồ băm hoặc danh sách mảng thành json và ngược lại.

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

Đi dự tiệc muộn nhưng đây là GSON của tôi nhà văn adhoc để tuần tự hóa hashmap. Tôi đã phải viết bản đồ của các cặp khóa-giá trị dưới dạng các thuộc tính chuỗi json, hy vọng một đặc trưng là loại số nguyên. Tôi không muốn tạo trình bao bọc JavaBean tùy chỉnh cho usecase đơn giản này.

Lớp GSON JsonWriter rất dễ sử dụng lớp serializer có chứa một vài hàm wr.value () được gõ mạnh.

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

Nếu không cần loại tùy chỉnh nào, tôi có thể sử dụng hàm toJson (). Thư viện gson-2.2.4.jar chỉ dưới 190KB mà không có bất kỳ sự phụ thuộc tàn bạo nào. Dễ dàng sử dụng trên mọi ứng dụng servlet tùy chỉnh hoặc ứng dụng độc lập mà không cần tích hợp khung lớn.

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

Đây thường là công việc của thư viện Json, bạn không nên cố gắng tự làm. Tất cả các thư viện json nên thực hiện những gì bạn đang yêu cầu và bạn có thể tìm thấy danh sách các thư viện Java Json trên json.org , ở cuối trang.

Tôi tìm thấy một cách khác để xử lý nó.

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

Hi vọng điêu nay co ich.

Cảm ơn.

Nếu bạn cần sử dụng nó trong mã.

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

Đối với những người sử dụng org.json.simple.JSONObject, bạn có thể chuyển đổi bản đồ thành Chuỗi Json và phân tích cú pháp để lấy JSONObject.

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

Thà muộn còn hơn không. Tôi đã sử dụng GSON để chuyển đổi danh sách HashMap thành chuỗi nếu trong trường hợp bạn muốn có một danh sách nối tiếp.

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

Điều này jsontạo ra[{"key":"value","key":"value","key":"value"}]

Đây là giải pháp một dòng của tôi với GSON:

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

Giải pháp này hoạt động với các JSON phức tạp:

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

chúng tôi sử dụng Gson.

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

Bạn có thể sử dụng XStream - nó thực sự tiện dụng. Xem các ví dụ ở đây

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

    }

}

Nếu bạn đang sử dụng net.sf.json.JSONObjectthì bạn sẽ không tìm thấy một nhà JSONObject(map)xây dựng trong đó. Bạn phải sử dụng public static JSONObject fromObject( Object object )phương pháp. Phương thức này chấp nhận các chuỗi được định dạng JSON, Maps, DynaBeans và JavaBeans.

JSONObject jsonObject = JSONObject.fromObject(myMap);

Nếu bạn sử dụng các đối tượng phức tạp, bạn nên áp dụng enableComplexMapKeySerialization () , như đã nêu trong https://stackoverflow.com/a/24635655/2914140 và 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));

Đầu ra sẽ là:

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

Không cần thư viện phân tích cú pháp Gson hoặc JSON. Chỉ cần sử dụng new JSONObject(Map<String, JSONObject>).toString(), ví dụ:

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

Nếu bạn không thực sự cần HashMap thì bạn có thể làm một cái gì đó như thế:

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

Đầu ra:

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

Tôi đang sử dụng Alibaba fastjson, dễ dàng và đơn giản:

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

và nhập khẩu:

import com.alibaba.fastjson.JSON;

Sau đó:

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

Mọi thứ ổn cả.

Nếu bạn đang sử dụng JSR 374: API Java để xử lý JSON (javax json) Điều này có vẻ như là một mẹo:

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

Bạn có thể sử dụng Gson . Thư viện này cung cấp các phương thức đơn giản để chuyển đổi các đối tượng Java thành các đối tượng JSON và ngược lại.

Thí dụ:

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

Bạn có thể sử dụng GsonBuilder khi bạn cần đặt các tùy chọn cấu hình khác với mặc định. Trong ví dụ trên, quá trình chuyển đổi cũng sẽ tuần tự hóa các thuộc tính null từ đối tượng.

Tuy nhiên, phương pháp này chỉ hoạt động cho các loại không chung chung. Đối với các loại chung, bạn cần sử dụng toJson (object, Type).

Thêm thông tin về Gson ở đây .

Hãy nhớ rằng đối tượng phải thực hiện giao diện Nối tiếp.

cái này hiệu quả với tôi

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

println new JsonBuilder(properties).toPrettyString()

Cách Gson cho các bản đồ và danh sách phức tạp hơn một chút bằng phương thức TypeToken.getParameterized :

Chúng tôi có một bản đồ trông như thế này:

Map<Long, List<NewFile>> map;

Chúng tôi nhận Loại bằng cách sử dụng phương thức getParameterized đã đề cập ở trên như sau:

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

Và sau đó sử dụng đối tượng Gson fromJson như thế này bằng cách sử dụng đối tượng mapOfList như thế này:

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

Đối tượng được đề cập NewFile trông như thế này:

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 được giải tuần tự trông như thế này:

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

Tôi đã phải đối mặt với một vấn đề tương tự khi giải tuần tự hóa Phản hồi từ các lệnh tùy chỉnh trong selenium. Phản hồi là json, nhưng selenium chuyển nội bộ thành java.util.HashMap [String, Object]

Nếu bạn quen thuộc với scala và sử dụng API chơi cho JSON, bạn có thể được hưởng lợi từ điều này:

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

Mô tả mã nhỏ:

Mã này đi qua đệ quy thông qua HashMap cho đến khi các loại cơ bản (String, Integer, Boolean) được tìm thấy. Các loại cơ bản này có thể được gói trực tiếp vào JsObject. Khi đệ quy được mở ra, phần sâu sẽ nối các đối tượng được tạo.

'@unchecked' quan tâm đến các cảnh báo xóa kiểu.

Đầu tiên chuyển đổi tất cả các đối tượng của bạn thành Chuỗi hợp lệ

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

Sau đó chèn toàn bộ bản đồ vào org.json.JSONObject

JSONObject postData = new JSONObject(params);

Bây giờ bạn có thể nhận JSON bằng cách gọi toString của đối tượng

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

Tạo một JSONObject mới

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

Hoặc dưới dạng một mảng byte để gửi qua HTTP

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