如何使用Gson将JSON转换为HashMap?


285

我正在从返回JSON格式数据的服务器请求数据。发出请求时,将HashMap转换为JSON并不困难,但另一种方式似乎有些棘手。JSON响应如下所示:

{ 
    "header" : { 
        "alerts" : [ 
            {
                "AlertID" : "2",
                "TSExpires" : null,
                "Target" : "1",
                "Text" : "woot",
                "Type" : "1"
            },
            { 
                "AlertID" : "3",
                "TSExpires" : null,
                "Target" : "1",
                "Text" : "woot",
                "Type" : "1"
            }
        ],
        "session" : "0bc8d0835f93ac3ebbf11560b2c5be9a"
    },
    "result" : "4be26bc400d3c"
}

哪种方法最容易访问此数据?我正在使用GSON模块。


23
Map<String,Object> result = new Gson().fromJson(json, Map.class);适用于gson 2.6.2。
Ferran Maylinch '16

1
如何转换回来?我的意思是从Map到Json Array。
K.Sopheak

Answers:


471

干得好:

import java.lang.reflect.Type;
import com.google.gson.reflect.TypeToken;

Type type = new TypeToken<Map<String, String>>(){}.getType();
Map<String, String> myMap = gson.fromJson("{'k1':'apple','k2':'orange'}", type);

6
不错,但是我不喜欢使用TypeToken-它确实在内部隐式转换。
2014年

投射到Map <>,您结束了我无聊的时光!
德克斯特(Dexter)

1
示例中的那个有效json吗?
埃文·凯鲁兹

@EvanKairuz不,不是。应该是{"k1":"apple","k2":"orange"}
Vadim Kotov

如果我需要转换实际上是数组的字符串怎么办
Ravi Yadav

111

此代码有效:

Gson gson = new Gson(); 
String json = "{\"k1\":\"v1\",\"k2\":\"v2\"}";
Map<String,Object> map = new HashMap<String,Object>();
map = (Map<String,Object>) gson.fromJson(json, map.getClass());

1
这会将int转换为float,然后再将其转换为字符串,但可以将JSON转换为map以进行比较。
louielouie 2012年

12
对我来说很棒,但我将地图更改为Map<String, Object>因为如果json不仅是字符串,还会出现错误
Moshe Shaham

5
这给人留下了错误的印象。参数化类型的正确解决方案是TypeToken
Sotirios Delimanolis 2016年

这将是所有类型的通用解决方案,但有点不常见。
莱昂,

76

我知道这是一个相当老的问题,但是我正在寻找一种解决方案,以将嵌套的JSON反序列化为Map<String, Object>,却一无所获。

我的yaml反序列化器的工作方式是,Map<String, Object>当您未指定类型时,它将JSON对象默认为,但是gson似乎没有这样做。幸运的是,您可以使用自定义解串器完成此操作。

我使用以下反序列化器对任何东西进行自然反序列化,将JsonObjects Map<String, Object>JsonArrays 缺省设置为Object[]s,所有子项都以类似方式反序列化。

private static class NaturalDeserializer implements JsonDeserializer<Object> {
  public Object deserialize(JsonElement json, Type typeOfT, 
      JsonDeserializationContext context) {
    if(json.isJsonNull()) return null;
    else if(json.isJsonPrimitive()) return handlePrimitive(json.getAsJsonPrimitive());
    else if(json.isJsonArray()) return handleArray(json.getAsJsonArray(), context);
    else return handleObject(json.getAsJsonObject(), context);
  }
  private Object handlePrimitive(JsonPrimitive json) {
    if(json.isBoolean())
      return json.getAsBoolean();
    else if(json.isString())
      return json.getAsString();
    else {
      BigDecimal bigDec = json.getAsBigDecimal();
      // Find out if it is an int type
      try {
        bigDec.toBigIntegerExact();
        try { return bigDec.intValueExact(); }
        catch(ArithmeticException e) {}
        return bigDec.longValue();
      } catch(ArithmeticException e) {}
      // Just return it as a double
      return bigDec.doubleValue();
    }
  }
  private Object handleArray(JsonArray json, JsonDeserializationContext context) {
    Object[] array = new Object[json.size()];
    for(int i = 0; i < array.length; i++)
      array[i] = context.deserialize(json.get(i), Object.class);
    return array;
  }
  private Object handleObject(JsonObject json, JsonDeserializationContext context) {
    Map<String, Object> map = new HashMap<String, Object>();
    for(Map.Entry<String, JsonElement> entry : json.entrySet())
      map.put(entry.getKey(), context.deserialize(entry.getValue(), Object.class));
    return map;
  }
}

handlePrimitive方法内部的混乱情况是为了确保您只能获得Double或Integer或Long,并且可能会更好,或者至少可以简化,如果可以使用BigDecimals,我相信这是默认设置。

您可以像以下方式注册该适配器:

GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.registerTypeAdapter(Object.class, new NaturalDeserializer());
Gson gson = gsonBuilder.create();

然后像这样调用它:

Object natural = gson.fromJson(source, Object.class);

我不确定为什么这不是gson中的默认行为,因为它在大多数其他半结构化序列化库中都存在。


1
...尽管我不太确定现在该如何处理返回的对象。即使我知道它们是字符串,似乎也无法将它们转换为String
Matt Zukowski

1
啊哈!诀窍是递归调用解串器,而不是context.deserialize()调用。
Matt Zukowski

1
你有代码马特吗?我努力让自己在解串器的变化,但我真的不能看到你的观点
罗曼·彼尔

5
现在,默认情况下,Gson在他的代码段中似​​乎具有Kevin Dolan想要的行为。
eleotlecram 2013年

1
@SomeoneSomewhere此处请参阅已接受的答案stackoverflow.com/questions/14944419/gson-to-hashmap

32

使用Google的Gson 2.7(可能也是早期版本,但我使用当前版本2.7进行了测试),操作非常简单:

Map map = gson.fromJson(jsonString, Map.class);

返回Map类型为a ,com.google.gson.internal.LinkedTreeMap并在嵌套对象,数组等上递归工作。

我像这样运行OP示例(用单引号简单地替换了double-并删除了空格):

String jsonString = "{'header': {'alerts': [{'AlertID': '2', 'TSExpires': null, 'Target': '1', 'Text': 'woot', 'Type': '1'}, {'AlertID': '3', 'TSExpires': null, 'Target': '1', 'Text': 'woot', 'Type': '1'}], 'session': '0bc8d0835f93ac3ebbf11560b2c5be9a'}, 'result': '4be26bc400d3c'}";
Map map = gson.fromJson(jsonString, Map.class);
System.out.println(map.getClass().toString());
System.out.println(map);

并得到以下输出:

class com.google.gson.internal.LinkedTreeMap
{header={alerts=[{AlertID=2, TSExpires=null, Target=1, Text=woot, Type=1}, {AlertID=3, TSExpires=null, Target=1, Text=woot, Type=1}], session=0bc8d0835f93ac3ebbf11560b2c5be9a}, result=4be26bc400d3c}

25

新Gson库的更新:
现在,您可以直接将嵌套的Json解析为Map,但要注意,以防您尝试解析Json进行Map<String, Object>键入:它将引发异常。要解决此问题,只需将结果声明为LinkedTreeMaptype。下面的例子:

String nestedJSON = "{"id":"1","message":"web_didload","content":{"success":1}};
Gson gson = new Gson();
LinkedTreeMap result = gson.fromJson(nestedJSON , LinkedTreeMap.class);

我从哪里导入LinkedTreeMap?我在Gson代码中找不到它。
HelpMeStackOverflowMyOnlyHope

我记得,LinkedTreeMap是在新的Gson lib中定义的。:您可以点击这里code.google.com/p/google-gson/source/browse/trunk/gson/src/main/...
晃阮胡

1
对我来说,它也适用Map<String,Object> result = gson.fromJson(json , Map.class);。使用gson 2.6.2。
Ferran Maylinch '16

12

我有完全相同的问题,并在这里结束。我采用了一种似乎更简单的方法(也许是gson的较新版本?)。

    Gson gson = new Gson();
    Map jsonObject = (Map) gson.fromJson(data, Object.class);

与以下json

{
  "map-00": {
    "array-00": [
      "entry-00",
      "entry-01"
     ],
     "value": "entry-02"
   }
}

以下

    Map map00 = (Map) jsonObject.get("map-00");
    List array00 = (List) map00.get("array-00");
    String value = (String) map00.get("value");
    for (int i = 0; i < array00.size(); i++) {
        System.out.println("map-00.array-00[" + i + "]= " + array00.get(i));
    }
    System.out.println("map-00.value = " + value);

输出

map-00.array-00[0]= entry-00
map-00.array-00[1]= entry-01
map-00.value = entry-02

您可以在浏览jsonObject时动态使用instanceof进行检查。就像是

Map json = gson.fromJson(data, Object.class);
if(json.get("field") instanceof Map) {
  Map field = (Map)json.get("field");
} else if (json.get("field") instanceof List) {
  List field = (List)json.get("field");
} ...

它对我有用,所以它必须对你有用;-)


6

自gson 2.8.0起支持以下功能

public static Type getMapType(Class keyType, Class valueType){
    return TypeToken.getParameterized(HashMap.class, keyType, valueType).getType();
}

public static  <K,V> HashMap<K,V> fromMap(String json, Class<K> keyType, Class<V> valueType){
    return gson.fromJson(json, getMapType(keyType,valueType));
}

3

试试这个,它将起作用。我将其用于Hashtable

public static Hashtable<Integer, KioskStatusResource> parseModifued(String json) {
    JsonObject object = (JsonObject) new com.google.gson.JsonParser().parse(json);
    Set<Map.Entry<String, JsonElement>> set = object.entrySet();
    Iterator<Map.Entry<String, JsonElement>> iterator = set.iterator();

    Hashtable<Integer, KioskStatusResource> map = new Hashtable<Integer, KioskStatusResource>();

    while (iterator.hasNext()) {
        Map.Entry<String, JsonElement> entry = iterator.next();

        Integer key = Integer.parseInt(entry.getKey());
        KioskStatusResource value = new Gson().fromJson(entry.getValue(), KioskStatusResource.class);

        if (value != null) {
            map.put(key, value);
        }

    }
    return map;
}

KioskStatusResource替换为您的类,将Integer替换为您的键类。


在HashMap抛出LinkedTreeMap异常之后,这对我有用。
newfivefour 2014年

2

这是我一直在使用的:

public static HashMap<String, Object> parse(String json) {
    JsonObject object = (JsonObject) parser.parse(json);
    Set<Map.Entry<String, JsonElement>> set = object.entrySet();
    Iterator<Map.Entry<String, JsonElement>> iterator = set.iterator();
    HashMap<String, Object> map = new HashMap<String, Object>();
    while (iterator.hasNext()) {
        Map.Entry<String, JsonElement> entry = iterator.next();
        String key = entry.getKey();
        JsonElement value = entry.getValue();
        if (!value.isJsonPrimitive()) {
            map.put(key, parse(value.toString()));
        } else {
            map.put(key, value.getAsString());
        }
    }
    return map;
}

2

这是一线可做的:

HashMap<String, Object> myMap =
   gson.fromJson(yourJson, new TypeToken<HashMap<String, Object>>(){}.getType());

是的,这是一行,但是请记住,new TypeToken<HashMap<String, Object>>(){}它将创建一个新的内联子类,并且至少我猜所有的
短毛猫

1

我已经使用Custom JsonDeSerializer克服了类似的问题。我试图使它有点通用,但还不够。虽然这是适合我需要的解决方案。

首先,您需要为Map对象实现一个新的JsonDeserializer。

public class MapDeserializer<T, U> implements JsonDeserializer<Map<T, U>>

反序列化方法看起来与此类似:

public Map<T, U> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
        throws JsonParseException {

        if (!json.isJsonObject()) {
            return null;
        }

        JsonObject jsonObject = json.getAsJsonObject();
        Set<Entry<String, JsonElement>> jsonEntrySet = jsonObject.entrySet();
        Map<T, U> deserializedMap = new HashMap<T, U>();

        for (Entry<java.lang.String, JsonElement> entry : jsonEntrySet) {
            try {
                U value = context.deserialize(entry.getValue(), getMyType());
                deserializedMap.put((T) entry.getKey(), value);
            } catch (Exception ex) {
                logger.info("Could not deserialize map.", ex);
            }
        }

        return deserializedMap;
    }

此解决方案的缺点是,我的地图的密钥始终为“字符串”类型。但是,通过修改某些东西,可以使它通用。另外,我需要说的是,该值的类应在构造函数中传递。所以方法getMyType(),我代码中返回Map值的类型,该值在构造函数中传递。

您可以参考这篇文章如何为Gson编写自定义JSON反序列化器?为了了解有关自定义解串器的更多信息。


1

您可以改用此类:)(甚至处理列表,嵌套列表和json)

public class Utility {

    public static Map<String, Object> jsonToMap(Object json) throws JSONException {

        if(json instanceof JSONObject)
            return _jsonToMap_((JSONObject)json) ;

        else if (json instanceof String)
        {
            JSONObject jsonObject = new JSONObject((String)json) ;
            return _jsonToMap_(jsonObject) ;
        }
        return null ;
    }


   private static Map<String, Object> _jsonToMap_(JSONObject json) throws JSONException {
        Map<String, Object> retMap = new HashMap<String, Object>();

        if(json != JSONObject.NULL) {
            retMap = toMap(json);
        }
        return retMap;
    }


    private static Map<String, Object> toMap(JSONObject object) throws JSONException {
        Map<String, Object> map = new HashMap<String, Object>();

        Iterator<String> keysItr = object.keys();
        while(keysItr.hasNext()) {
            String key = keysItr.next();
            Object value = object.get(key);

            if(value instanceof JSONArray) {
                value = toList((JSONArray) value);
            }

            else if(value instanceof JSONObject) {
                value = toMap((JSONObject) value);
            }
            map.put(key, value);
        }
        return map;
    }


    public static List<Object> toList(JSONArray array) throws JSONException {
        List<Object> list = new ArrayList<Object>();
        for(int i = 0; i < array.length(); i++) {
            Object value = array.get(i);
            if(value instanceof JSONArray) {
                value = toList((JSONArray) value);
            }

            else if(value instanceof JSONObject) {
                value = toMap((JSONObject) value);
            }
            list.add(value);
        }
        return list;
    }
}

要将您的JSON字符串转换为hashmap,请使用以下命令:

HashMap<String, Object> hashMap = new HashMap<>(Utility.jsonToMap(response)) ;

0

这不是凯文·多兰(Kevin Dolan)的答案的补充,而不是完整的答案,但是我在从数字中提取类型时遇到了麻烦。这是我的解决方案:

private Object handlePrimitive(JsonPrimitive json) {
  if(json.isBoolean()) {
    return json.getAsBoolean();
  } else if(json.isString())
    return json.getAsString();
  }

  Number num = element.getAsNumber();

  if(num instanceof Integer){
    map.put(fieldName, num.intValue());
  } else if(num instanceof Long){
    map.put(fieldName, num.longValue());
  } else if(num instanceof Float){
    map.put(fieldName, num.floatValue());
  } else {    // Double
     map.put(fieldName, num.doubleValue());
  }
}

-1
 HashMap<String, String> jsonToMap(String JsonDetectionString) throws JSONException {

    HashMap<String, String> map = new HashMap<String, String>();
    Gson gson = new Gson();

    map = (HashMap<String, String>) gson.fromJson(JsonDetectionString, map.getClass());

    return map;

}

-3

JSONObject通常在HashMap内部使用存储数据。因此,您可以在代码中将其用作Map。

例,

JSONObject obj = JSONObject.fromObject(strRepresentation);
Iterator i = obj.entrySet().iterator();
while (i.hasNext()) {
   Map.Entry e = (Map.Entry)i.next();
   System.out.println("Key: " + e.getKey());
   System.out.println("Value: " + e.getValue());
}

12
这是来自json-lib,而不是gson!
Ammar

-3

我使用以下代码:

Gson gson = new Gson();
HashMap<String, Object> fields = gson.fromJson(json, HashMap.class);

这给了我未经检查的转换警告。
线
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.