Java에서 해시 맵을 JSON 객체로 변환하는 방법

Java에서 해시 맵을 JSON 객체로 변환하거나 캐스트하고 JSON 객체를 다시 JSON 문자열로 변환하는 방법은 무엇입니까?

당신이 사용할 수있는:

new JSONObject(map);

주의 : 이 기능은Map<String, String>!

설명서 http://stleary.github.io/JSON-java/index.html 에서 얻을 수있는 다른 기능

Gson 을 사용하여 임의로 복잡한 객체를 직렬화 할 수도 있습니다.

사용 방법은 다음과 같습니다.

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

Gson컬렉션을 JSON배열 로 자동 변환 합니다. Gson은 개인 필드를 직렬화하고 임시 필드를 자동으로 무시합니다.

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

산출::

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

Google의 GSON을 사용해보십시오 .Google의 GSON은 Java 객체를 JSON 표현으로 변환하는 데 사용할 수있는 최고의 라이브러리입니다.

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

다음과 같이 사용하여 변환 Map할 수 있습니다 .JSONJackson

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 종속성 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>

JSONObject라이브러리 를 사용하는 경우 맵을 JSON다음과 같이 변환 할 수 있습니다 .

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 종속성 JSONObject:

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

이것이 도움이되기를 바랍니다. 행복한 코딩.

제 경우에는 의존성을 원하지 않았습니다. Java 8을 사용하면 JSON을 다음과 같은 간단한 문자열로 얻을 수 있습니다.

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

지도를 열거하고 키-값 쌍을 JSONObject에 추가하면됩니다.

방법 :

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

Underscore-java 라이브러리는 해시 맵 또는 배열 목록을 json으로 변환하거나 그 반대로 변환 할 수 있습니다.

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

파티에 늦었지만 여기 내 GSON이 있습니다. 해시 맵을 직렬화하기위한 임시 작가입니다. 키-값 쌍의 맵을 json 문자열 속성으로 작성해야했으며 특정 유형은 정수 유형이어야합니다. 이 간단한 유스 케이스에 대한 사용자 정의 JavaBean 랩퍼를 작성하고 싶지 않았습니다.

GSON JsonWriter 클래스는 강력하게 형식화 된 writer.value () 함수가 거의없는 시리얼 라이저 클래스를 사용하기 쉽습니다.

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

사용자 정의 유형이 필요하지 않으면 toJson () 함수를 사용할 수 있습니다. gson-2.2.4.jar 라이브러리는 잔인한 종속성없이 190KB 미만입니다. 큰 프레임 워크 통합없이 모든 사용자 정의 서블릿 앱 또는 독립형 애플리케이션에서 사용하기 쉽습니다.

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

이것은 일반적으로 Json 라이브러리의 작업이므로 직접 시도하지 마십시오. 모든 json 라이브러리는 요청한 것을 구현해야 하며 페이지 하단의 json.org 에서 Java Json 라이브러리 목록을 찾을 수 있습니다 .

나는 그것을 처리하는 다른 방법을 찾았다.

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

도움이 되었기를 바랍니다.

감사.

코드에서 사용해야하는 경우

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

을 사용하는 org.json.simple.JSONObject사용자의 경우 맵을 Json String으로 변환하고 구문 분석하여을 얻을 수 있습니다 JSONObject.

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

결코 늦지 않는 것이 낫습니다. 직렬화 된 목록을 원할 경우 GSON 을 사용 하여 HashMap 목록을 문자열로 변환했습니다.

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

이것은 json생산[{"key":"value","key":"value","key":"value"}]

다음은 GSON을 사용한 한 줄 솔루션입니다.

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

이 솔루션은 복잡한 JSON과 함께 작동합니다.

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

우리는 Gson을 사용합니다.

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

XStream을 사용할 수 있습니다-정말 편리합니다. 여기 예를 참조 하십시오

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

    }

}

사용하는 경우 생성자를 net.sf.json.JSONObject찾을 수 없습니다 JSONObject(map). 이 public static JSONObject fromObject( Object object )방법 을 사용해야합니다 . 이 메소드는 JSON 형식의 문자열, 맵, DynaBean 및 JavaBean을 허용합니다.

JSONObject jsonObject = JSONObject.fromObject(myMap);

복잡한 객체를 사용하는 경우 https://stackoverflow.com/a/24635655/2914140 및 https://stackoverflow.com/a/26374888/2914140에 설명 된대로 enableComplexMapKeySerialization ()을 적용해야합니다 .

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

출력은 다음과 같습니다.

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

Gson 또는 JSON 구문 분석 라이브러리가 필요하지 않습니다. 그냥 사용 new JSONObject(Map<String, JSONObject>).toString()예 :

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

실제로 HashMap이 필요하지 않으면 다음과 같이 할 수 있습니다.

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

산출:

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

쉽고 빠르게 Alibaba fastjson을 사용하고 있습니다.

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

그리고 수입품 :

import com.alibaba.fastjson.JSON;

그때:

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

다 괜찮아

JSR 374 : JSON 처리를위한 Java API (javax json)를 사용하는 경우 다음과 같은 트릭을 수행하는 것 같습니다.

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

Gson 을 사용할 수 있습니다 . 이 라이브러리는 Java 객체를 JSON 객체로 변환하거나 그 반대로 변환하는 간단한 방법을 제공합니다.

예:

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

기본값 이외의 구성 옵션을 설정해야하는 경우 GsonBuilder를 사용할 수 있습니다. 위의 예에서 변환 프로세스는 개체의 null 특성도 직렬화합니다.

그러나이 방법은 제네릭이 아닌 유형에만 적용됩니다. 제네릭 형식의 경우 toJson (object, Type)을 사용해야합니다.

Gson에 대한 자세한 정보는 여기 .

객체는 Serializable 인터페이스를 구현해야합니다 .

이것은 나를 위해 작동합니다 :

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

println new JsonBuilder(properties).toPrettyString()

TypeToken.getParameterized 메소드를 사용하여 좀 더 복잡한 맵과 목록을 만드는 방법 :

다음과 같은 맵이 있습니다.

Map<Long, List<NewFile>> map;

위에서 언급 한 getParameterized 메소드를 사용하여 Type을 얻습니다 .

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

그리고 다음 GSON 개체 사용 fromJson의 사용하여 다음과 같은 방법을 mapOfList의 이 같은 개체를 :

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

언급 된 NewFile 객체 는 다음과 같습니다.

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은 다음과 같습니다.

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

셀레늄의 사용자 정의 명령에서 응답을 직렬화 해제 할 때 비슷한 문제에 직면했습니다. 응답은 json이지만 셀레늄은 내부적으로 java.util.HashMap [String, Object]로 변환합니다.

스칼라에 익숙하고 play-API for JSON을 사용하는 경우 다음과 같은 이점이 있습니다.

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

작은 코드 설명 :

코드는 기본 유형 (String, Integer, Boolean)이 발견 될 때까지 HashMap을 통해 재귀 적으로 순회합니다. 이러한 기본 유형은 JsObject에 직접 랩핑 될 수 있습니다. 재귀가 전개 될 때 심층 병합은 작성된 오브젝트를 연결합니다.

'@checked'는 유형 삭제 경고를 처리합니다.

먼저 모든 객체를 유효한 문자열로 변환하십시오.

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

그런 다음 전체 맵을 org.json.JSONObject에 삽입하십시오.

JSONObject postData = new JSONObject(params);

이제 객체의 toString을 호출하여 JSON을 얻을 수 있습니다.

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

새로운 JSONObject 생성

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

또는 HTTP를 통한 전송을위한 바이트 배열

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