使用 Gson 反序列化 List<T> 对象？

反序列化泛型集合的方法：

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

...

Type listType = new TypeToken<ArrayList<YourClass>>(){}.getType();
List<YourClass> yourClassList = new Gson().fromJson(jsonArray, listType);

由于评论中有几个人提到了它，这里解释一下如何使用 TypeToken 类。构造 new TypeToken<...>() {}.getType() 将编译时类型（在 < 和 > 之间）捕获到运行时 java.lang.reflect.Type 对象中。与只能表示原始（已擦除）类型的 Class 对象不同，Type 对象可以表示 Java 语言中的任何类型，包括泛型类型的参数化实例化。

TypeToken 类本身没有公共构造函数，因为您不应该直接构造它。相反，您总是构造一个匿名子类（因此 {}，它是这个表达式的必要部分）。

由于类型擦除，TypeToken 类只能捕获在编译时完全已知的类型。 （也就是说，您不能对类型参数 T 执行 new TypeToken<List<T>>() {}.getType()。）

有关详细信息，请参阅 documentation for the TypeToken class。

另一种方法是使用数组作为类型，例如：

MyClass[] mcArray = gson.fromJson(jsonString, MyClass[].class);

这样你就避免了 Type 对象的所有麻烦，如果你真的需要一个列表，你总是可以通过以下方式将数组转换为列表：

List<MyClass> mcList = Arrays.asList(mcArray);

恕我直言，这更具可读性。

要使其成为实际列表（可以修改，请参阅 Arrays.asList() 的限制），只需执行以下操作：

List<MyClass> mcList = new ArrayList<>(Arrays.asList(mcArray));

从 Gson 2.8 开始，我们可以像这样创建 util 函数：

public <T> List<T> getList(String jsonArray, Class<T> clazz) {
    Type typeOfT = TypeToken.getParameterized(List.class, clazz).getType();
    return new Gson().fromJson(jsonArray, typeOfT);
}

示例用法：

String jsonArray = ...
List<User> user = getList(jsonArray, User.class);

参考这篇文章。 Java Type Generic as Argument for GSON

我对此有更好的解决方案。这是列表的包装器类，因此包装器可以存储列表的确切类型。

public class ListOfJson<T> implements ParameterizedType
{
  private Class<?> wrapped;

  public ListOfJson(Class<T> wrapper)
  {
    this.wrapped = wrapper;
  }

  @Override
  public Type[] getActualTypeArguments()
  {
      return new Type[] { wrapped };
  }

  @Override
  public Type getRawType()
  {
    return List.class;
  }

  @Override
  public Type getOwnerType()
  {
    return null;
  }
}

然后，代码可以很简单：

public static <T> List<T> toList(String json, Class<T> typeClass)
{
    return sGson.fromJson(json, new ListOfJson<T>(typeClass));
}

Wep，另一种实现相同结果的方法。我们使用它是因为它的可读性。

而不是做这个难以阅读的句子：

Type listType = new TypeToken<ArrayList<YourClass>>(){}.getType();
List<YourClass> list = new Gson().fromJson(jsonArray, listType);

创建一个扩展对象列表的空类：

public class YourClassList extends ArrayList<YourClass> {}

并在解析 JSON 时使用它：

List<YourClass> list = new Gson().fromJson(jsonArray, YourClassList.class);

对于 Kotlin 来说：

import java.lang.reflect.Type
import com.google.gson.reflect.TypeToken
...
val type = object : TypeToken<List<T>>() {}.type

或者，这是一个有用的功能：

fun <T> typeOfList(): Type {
    return object : TypeToken<List<T>>() {}.type
}

然后，使用：

val type = typeOfList<YourMagicObject>()

public static final <T> List<T> getList(final Class<T[]> clazz, final String json)
{
    final T[] jsonToObject = new Gson().fromJson(json, clazz);

    return Arrays.asList(jsonToObject);
}

例子：

getList(MyClass[].class, "[{...}]");

因为它回答了我最初的问题，所以我已经接受了 doc_180 的回答，但是如果有人再次遇到这个问题，我也会回答我的问题的后半部分：

我描述的 NullPointerError 与 List 本身无关，而是与它的内容有关！

“MyClass”类没有“无参数”构造函数，也没有它的超类。一旦我向 MyClass 及其超类添加了一个简单的“MyClass()”构造函数，一切正常，包括 doc_180 建议的列表序列化和反序列化。

这是一个适用于动态定义类型的解决方案。诀窍是使用 Array.newInstance() 创建正确类型的数组。

public static <T> List<T> fromJsonList(String json, Class<T> clazz) {
    Object [] array = (Object[])java.lang.reflect.Array.newInstance(clazz, 0);
    array = gson.fromJson(json, array.getClass());
    List<T> list = new ArrayList<T>();
    for (int i=0 ; i<array.length ; i++)
        list.add(clazz.cast(array[i]));
    return list; 
}

我想增加一种可能性。如果您不想使用 TypeToken 并且想将 json 对象数组转换为 ArrayList，那么您可以这样进行：

如果你的 json 结构是这样的：

{

"results": [
    {
        "a": 100,
        "b": "value1",
        "c": true
    },
    {
        "a": 200,
        "b": "value2",
        "c": false
    },
    {
        "a": 300,
        "b": "value3",
        "c": true
    }
]

}

你的班级结构是这样的：

public class ClassName implements Parcelable {

    public ArrayList<InnerClassName> results = new ArrayList<InnerClassName>();
    public static class InnerClassName {
        int a;
        String b;
        boolean c;      
    }
}

然后你可以像这样解析它：

Gson gson = new Gson();
final ClassName className = gson.fromJson(data, ClassName.class);
int currentTotal = className.results.size();

现在您可以访问 className 对象的每个元素。

有关 Gson 的“类型”类理解，请参阅示例 2。

示例 1：在这个 deserilizeResturant 中，我们使用了 Employee[] 数组并获取了详细信息

public static void deserializeResturant(){

       String empList ="[{\"name\":\"Ram\",\"empId\":1},{\"name\":\"Surya\",\"empId\":2},{\"name\":\"Prasants\",\"empId\":3}]";
       Gson gson = new Gson();
       Employee[] emp = gson.fromJson(empList, Employee[].class);
       int numberOfElementInJson = emp.length();
       System.out.println("Total JSON Elements" + numberOfElementInJson);
       for(Employee e: emp){
           System.out.println(e.getName());
           System.out.println(e.getEmpId());
       }
   }

示例 2：

//Above deserilizeResturant used Employee[] array but what if we need to use List<Employee>
public static void deserializeResturantUsingList(){

    String empList ="[{\"name\":\"Ram\",\"empId\":1},{\"name\":\"Surya\",\"empId\":2},{\"name\":\"Prasants\",\"empId\":3}]";
    Gson gson = new Gson();

    // Additionally we need to se the Type then only it accepts List<Employee> which we sent here empTypeList
    Type empTypeList = new TypeToken<ArrayList<Employee>>(){}.getType();


    List<Employee> emp = gson.fromJson(empList, empTypeList);
    int numberOfElementInJson = emp.size();
    System.out.println("Total JSON Elements" + numberOfElementInJson);
    for(Employee e: emp){
        System.out.println(e.getName());
        System.out.println(e.getEmpId());
    }
}

使用 Kotlin，您可以获得所有自定义 Serializable 类型的通用 MutableList 类型

private fun <T : Serializable> getGenericList(
    sharedPreferences: SharedPreferences,
    key: String,
    clazz: KClass<T>
): List<T> {
    return sharedPreferences.let { prefs ->
        val data = prefs.getString(key, null)
        val type: Type = TypeToken.getParameterized(MutableList::class.java, clazz.java).type
        gson.fromJson(data, type) as MutableList<T>
    }
}

你可以调用这个函数

getGenericList.(sharedPrefObj, sharedpref_key, GenericClass::class)

在我的情况下，@uncaught_exceptions 的答案不起作用，我不得不使用 List.class 而不是 java.lang.reflect.Type：

String jsonDuplicatedItems = request.getSession().getAttribute("jsonDuplicatedItems").toString();
List<Map.Entry<Product, Integer>> entries = gson.fromJson(jsonDuplicatedItems, List.class);

我为此案例创建了 GsonUtils 库。我将它添加到 Maven 中央存储库中。

Map<String, SimpleStructure> expected = new HashMap<>();
expected.put("foo", new SimpleStructure("peperoni"));

String json = GsonUtils.writeValue(expected);

Map<String, SimpleStructure> actual = GsonUtils.readMap(json, String.class, SimpleStructure.class);

我喜欢 kays1 的答案，但我无法实现它。所以我使用他的概念构建了我自己的版本。

public class JsonListHelper{
    public static final <T> List<T> getList(String json) throws Exception {
        Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
        Type typeOfList = new TypeToken<List<T>>(){}.getType();
        return gson.fromJson(json, typeOfList);
    }
}

用法：

List<MyClass> MyList= JsonListHelper.getList(jsonArrayString);