gson转化为带泛型的Map(K, V)：com.google.gson.internal.LinkedTreeMap cannot be cast to xx(entity)

public <K, V> Map<K, V> toMap2(String json, Class<K> kClazz, Class<V> vClazz) {
    return sGson.fromJson(json, new TypeToken<Map<K, V>>() {}.getType());
}

解决方法

（零）、TypeToken解决

    /**
     * @param json map的序列化结果
     * @param <K>   k类型
     * @param <V>   v类型
     * @return Map<K       ,       V>
     */
    public <K, V> Map<K, V> toMap(String json, Class<K> kClazz, Class<V> vClazz) {
        return sGson.fromJson(json,TypeToken.getParameterized(Map.class,kClazz,vClazz).getType());
    }

其他几种解决思路

（一）、当Map的Key为String类型时

为什么要特别说明为key为String呢，因为不管你的Key为什么类型，通过Gson还原时得到的LinkedTreeMap 的 key都为String类型。

此时通过JsonObject即可解决

正确代码1：

    public <V> Map<String, V> toStringKeyMap(String json, Class<V> vClazz) {
        Map<String, V> map = new HashMap<>();
        try {
            JsonObject obj = new JsonParser().parse(json).getAsJsonObject();
            Set<Map.Entry<String, JsonElement>> entrySet = obj.entrySet();
            for (Map.Entry<String, JsonElement> entry : entrySet) {
                String entryKey = entry.getKey();
                JsonObject object = (JsonObject) entry.getValue();
                V value = sGson.fromJson(object, vClazz);
                map.put(entryKey, value);
            }
        } catch (Exception e) {
            return null;
        }
        return map;
    }

你可能会问，那怎么不用JsonObject转化 JsonObject kobject = (JsonObject) entry.getKey() ， 那样不就解决问题了

因为Key被映射为String类型了，目前还没找到解决办法，也不打算在这中地方深追下去了，太费时间了。

（二）、通过由Map的key组成的List，和有value组成的List解决

思路：先得到由Map的Key组成的keyList，再得到由value组成的valueList；之后分别序列化keyList、valueList。反序列化时，也是分别对keyList和valueList反序列化，在依次添加到map中去

正确代码2：

（1）得到keyList和vList

/**
     * @param map map对象
     * @param <K> k类型
     * @param <V> v类型
     * @return keyList
     */
    public static <K, V> List<K> getMapKeyList(Map<K, V> map, Class<K> kClazz, Class<V> vClazz) {
        List<K> keyList = new ArrayList<>();
        for (Map.Entry<K, V> entry : map.entrySet()) {
            keyList.add(entry.getKey());
        }
        return keyList;
    }

    /**
     * @param map     map对象
     * @param keyList 由map的key组成的keyList
     * @param <K>     k类型
     * @param <V>     v类型
     * @return valueList
     */
    public static <K, V> List<V> getMapValueListByKey(Map<K, V> map, List<K> keyList, Class<K> kClazz, Class<V> vClazz) {
        List<V> valueList = new ArrayList<>();

        for (K k : keyList) {
            V v = map.get(k);
            valueList.add(v);
        }

        return valueList;
    }

（2）序列化keyList和valueList

    private Gson sGson = new Gson();

    public String toJson(Object object) {
        return sGson.toJson(object);
    }

（3）反序列化keyList和valueList，得到map

    /**
     * @param kJson keyList的序列化结果
     * @param vJson valueList的序列化结果
     * @param <K>   k类型
     * @param <V>   v类型
     * @return Map<K   ,   V>
     */
    public <K, V> Map<K, V> toMap(String kJson, String vJson, Class<K> kClazz, Class<V> vClazz) {
        Map<K, V> map = new HashMap<>();
        try {
            List<K> kList = toList(kJson, kClazz);
            List<V> vList = toList(vJson, vClazz);
            for (int i = 0; i < kList.size(); i++) {
                K k = kList.get(i);
                V v = vList.get(i);
                map.put(k, v);
            }
        } catch (Exception e) {
            return null;
        }
        return map;
    }

    /**
     * @param json list的序列化字符串
     * @param <T>  T类型
     * @return List<T>
     */
    public <T> List<T> toList(String json, Class<T> clazz) {
        List<T> list = new ArrayList<>();
        try {
            JsonArray array = new JsonParser().parse(json).getAsJsonArray();
            for (final JsonElement elem : array) {
                list.add(new Gson().fromJson(elem, clazz));
            }
        } catch (Exception e) {
            return null;
        }
        return list;
    }

乐奇 Rokid 开放社区

更多推荐