如何在 Java 中将 hashmap 转换为 JSON 对象答案

【问题标题】：How to convert hashmap to JSON object in Java如何在 Java 中将 hashmap 转换为 JSON 对象
【发布时间】：2012-08-22 18:09:48
【问题描述】：

如何在 Java 中将 hashmap 转换或强制转换为 JSON 对象，并再次将 JSON 对象转换为 JSON 字符串？

【问题讨论】：

可以像objectMapper.objectMapper.writeValueAsString(hasMap))一样直接使用ObjectMapper

标签： java json

【解决方案1】：

你可以使用：

new JSONObject(map);

注意：这仅适用于Map<String, String>!

您可以从其文档中获得的其他功能
http://stleary.github.io/JSON-java/index.html

【讨论】：

这仅适用于字符串、字符串映射，而不适用于复杂的字符串、对象。
您将Map 放入JSONObject 但如何从jsonObject 获取此地图？
@Yubi 这可能对你有帮助：stackoverflow.com/questions/21720759/convert-jsonobject-to-map
@slott 适合旧版本。像 kitkat 这样的新版本可以很好地处理更复杂的对象，比如包含 HashMap() 作为对象的 HashMap()。所以我推荐 Gson。
转换为 JSON 字符串而不是 JSON 对象：new ObjectMapper().writeValueAsString(map);

【解决方案2】：

Gson也可以用来序列化任意复杂的对象。

这是你如何使用它：

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

Gson 将自动将集合转换为 JSON 数组。 Gson 可以序列化私有字段并自动忽略瞬态字段。

【讨论】：

注意：这不会保留具有空值的键。
您的帖子如何回答这个问题？这太令人困惑了。请同时提及与问题相关的内容。
注意：当您以 Integer 发送一些值时，此转换为 double。

【解决方案3】：

您可以使用Jackson 将Map 转换为JSON，如下所示：

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

Jackson 的 Maven 依赖项：

<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` 库，您可以将 map 转换为 `JSON`，如下所示：

JSON 对象库： import org.json.JSONObject;

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

`JSONObject` 的 Maven 依赖项：

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

希望这会有所帮助。快乐编码。

【讨论】：

不知道我可以将 Map 作为参数传递，谢谢，帮了大忙。
@Gurkha 感谢您的欣赏。
@AnkurMahajan +1 给予正确的答案与依赖:)
String json = new ObjectMapper().writeValueAsString(map);伟大的

【解决方案4】：

使用 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/

【讨论】：

抱歉，2 在json.toString(2 中做了什么`)
public String toString(int radix).toString(2) 用于字符串表示。更多stackoverflow.com/questions/3615721/…
这是哪个 JSONObject 类？
没有这样的方法：(new org.json.JSONObject()).putAll();

【解决方案5】：

就我而言，我不想要任何依赖项。使用 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(", "))+"}";

【讨论】：

你没有转义...如果键或值包含"，这会中断
你说得对，这个方案有一定的局限性，也不支持嵌套地图

【解决方案6】：

您可以只枚举映射并将键值对添加到 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;
}

【讨论】：

没有快捷方式，无需任何额外库即可有效工作
Map.Entry> entrySet() 用于地图的迭代。读取键并在地图上搜索每个键是一种次优方式。

【解决方案7】：

Underscore-java库可以将哈希映射或数组列表转换为json，反之亦然。

import com.github.underscore.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"
        // }
    }
}

【讨论】：

【解决方案8】：

聚会迟到了，但这是我的 GSON 用于序列化 hashmap 的临时作者。我必须将键值对映射写为 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，没有任何残酷的依赖。易于在任何自定义 servlet 应用程序或独立应用程序上使用，无需大型框架集成。

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

【讨论】：

【解决方案9】：

如果你需要在代码中使用它。

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

【讨论】：

这个就是 GSON！

【解决方案10】：

这通常是 Json 库的工作，你不应该尝试自己做。所有 json 库都应该实现你所要求的，你可以在页面底部的json.org 上找到 Java Json 库列表。

【讨论】：

【解决方案11】：

此解决方案适用于复杂的 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;
    }
}

【讨论】：

【解决方案12】：

迟到总比不到好。如果您想要一个序列化列表，我使用 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"}]

【讨论】：

这不能回答问题。它正在生成 JSON 数组，而不是 JSON 对象。其他人已经向我们展示了如何使用 Gson 从 hashmap 创建 JSON 对象。
嗨@StephenC，有些人可能会寻找 JSON 数组而不是 JSON 对象的示例，因为到目前为止，顶级评论已经提供了最佳答案。我希望我们可以提供与使用 GSON 进行序列化相关的其他答案。抱歉，这个答案应该发布在不同的线程上。
我们应该为正确搜索的人写答案。如果我们试图通过发布偏离主题的答案来迎合无法搜索的人，它会因“噪音”而降低网站质量，并使知道如何搜索的人更难找到相关答案.如果您（现在）同意此答案位于错误的位置，请删除它。
@KellyBudol 好坏，你的答案就是我要找的。谢谢男人

【解决方案13】：

这是我的 GSON 单线解决方案：

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

【讨论】：

【解决方案14】：

对于那些使用org.json.simple.JSONObject 的人，您可以将映射转换为 Json 字符串并对其进行解析以获取 JSONObject。

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

【讨论】：

【解决方案15】：

我找到了另一种处理方式。

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

希望这会有所帮助。

谢谢。

【讨论】：

【解决方案16】：

我们使用 Gson。

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

【讨论】：

【解决方案17】：

如果你真的不需要 HashMap，那么你可以这样做：

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

输出：

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

【讨论】：

嗯，是的。但是，该问题要求一种创建 JSON 对象的方法从HashMap 开始，而这并没有回答这个问题。
有些人可能会从谷歌登陆这里寻找通用解决方案。以上答案可能对他们有所帮助。

【解决方案18】：

我用的是阿里巴巴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

一切正常。

【讨论】：

【解决方案19】：

如果您使用 JSR 374：用于 JSON 处理的 Java API ( javax json ) 这似乎可以解决问题：

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

【讨论】：

【解决方案20】：

您可以使用 XStream - 它真的很方便。见例子here

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

    }

}

【讨论】：

但是你应该缓存你的 xstream 对象任何人

【解决方案21】：

如果您使用的是net.sf.json.JSONObject，那么您将不会在其中找到JSONObject(map) 构造函数。您必须使用public static JSONObject fromObject( Object object ) 方法。此方法接受 JSON 格式的字符串、Maps、DynaBeans 和 JavaBeans。

JSONObject jsonObject = JSONObject.fromObject(myMap);

【讨论】：

【解决方案22】：

如果您使用复杂对象，则应应用 enableComplexMapKeySerialization()，如 https://stackoverflow.com/a/24635655/2914140 和 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));

输出将是：

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

【讨论】：

【解决方案23】：

无需 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 "{}";
    }
}

【讨论】：

吞下异常并返回一个空对象是个坏主意。

【解决方案24】：

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

【讨论】：

这只是重复之前的答案。

【解决方案25】：

使用 TypeToken.getParameterized 方法的更复杂的地图和列表的 Gson 方法：

我们的地图如下所示：

Map<Long, List<NewFile>> map;

我们使用上面提到的 getParameterized 方法获取类型，如下所示：

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

然后像这样使用mapOfList对象这样使用Gson对象fromJson方法：

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

【讨论】：

【解决方案26】：

您可以使用Gson。这个库提供了简单的方法来将 Java 对象转换为 JSON 对象，反之亦然。

例子：

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

当您需要设置非默认配置选项时，您可以使用 GsonBuilder。在上面的例子中，转换过程也会从 object 中序列化 null 属性。

但是，这种方法仅适用于非泛型类型。对于泛型类型，您需要使用 toJson(object, Type)。

更多关于Gson的信息here。

记住对象必须实现Serializable接口。

【讨论】：

【解决方案27】：

这对我有用：

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

println new JsonBuilder(properties).toPrettyString()

【讨论】：

这不是一个 Groovy 问题。
@stephen-c java 是一个平台，而不仅仅是语言，groovy 只是一个罐子。
您问题中的代码不是 Java。如果该代码确实对您有用，那么您就没有使用 Java。 Java 没有“println”语句，你不能像那样声明变量。我的猜测是您使用的是 Groovy，但我不确定。无论哪种方式，推荐人们在 Java 代码中使用 Groovy 库而不是 Java 库......不是一个好主意。

【解决方案28】：

从 selenium 中的自定义命令反序列化响应时，我遇到了类似的问题。响应是 json，但 selenium 在内部将其转换为 java.util.HashMap[String, Object]

如果您熟悉 scala 并使用 JSON 的 play-API，您可能会从中受益：

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

小代码说明：

代码递归遍历 HashMap，直到找到基本类型（String、Integer、Boolean）。这些基本类型可以直接包装到一个 JsObject 中。当递归展开时，deepmerge 将创建的对象连接起来。

'@unchecked' 负责处理类型擦除警告。

【讨论】：

这不是 Scala 问题

【解决方案29】：

首先将所有对象转换为有效字符串

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

【讨论】：

这与多年前以前的答案所说的相同，但没有简洁的优势。
@StephenC 我不知道你在说什么
@StephenC "如何在 Java 中将 hashmap 转换或转换为 JSON 对象，并再次将 JSON 对象转换为 JSON 字符串？"
362 人（并且还在增加）认为stackoverflow.com/a/12155874/139985 回答了这个问题。它基本上说明了你的答案所说的没有多余的部分。