Wep，另一种达到同样效果的方法。我们使用它是为了它的可读性。

不要写这个难以读懂的句子:

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

创建一个扩展对象List的空类:

public class YourClassList extends ArrayList<YourClass> {}

并在解析JSON时使用它:

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

下面是一个使用动态定义类型的解决方案。诀窍在于使用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; 
}

参考这篇文章。 Java类型泛型作为GSON的参数

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

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

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

方法反序列化泛型集合:

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类的解释。构造新的TypeToken<…>(){}. gettype()将一个编译时类型(介于<和>之间)捕获到运行时java.lang.reflect.Type对象中。Class对象只能表示原始(擦除的)类型，而type对象可以表示Java语言中的任何类型，包括泛型类型的参数化实例化。

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

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

有关更多信息，请参阅TypeToken类的文档。

对于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>()