Google Gson-deserializar objeto de lista? (tipo genérico)

Otra forma es usar un array como tipo, por ejemplo:

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

De esta manera evitará toda la molestia con el objeto de tipo, y si realmente necesita una lista, siempre puede convertir la matriz en una lista mediante:

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

En mi humilde opinión esto es mucho más legible.

Y para que sea una lista real (que se puede modificar, ver limitaciones de Arrays.asList()), simplemente haga lo siguiente:

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

Consulte este post. Java Type Generic como Argumento para GSON

Tengo una mejor solución para esto. Aquí está la clase wrapper for list para que el wrapper pueda almacenar exactamente el tipo de lista.

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

Y luego, el código puede ser simple:

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

Wep, otra forma de lograr el mismo resultado. Lo usamos por su legibilidad.

En lugar de hacer esta oración difícil de leer:

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

Cree una clase vacía que extienda una Lista de su objeto:

public class YourClassList extends ArrayList<YourClass> {}

Y úselo al analizar el JSON:

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

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

Ejemplo:

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

Como responde a mi pregunta original, he aceptado la respuesta de doc_180, pero si alguien se encuentra con este problema de nuevo, voy a responder la segunda mitad de mi pregunta también:

El NullPointerError que describí no tenía nada que ver con la Lista en sí, ¡sino con su contenido!

La clase "MyClass" no tenía un constructor "no args", y tampoco tenía su superclase. Una vez que agregué un constructor simple" MyClass () " a MyClass y su superclase, todo funcionó bien, incluyendo Lista de serialización y deserialización como sugiere doc_180.

Aquí hay una solución que funciona con un tipo definido dinámicamente. El truco es crear el tipo adecuado de matriz usando matriz.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; 
}

Para Kotlin simplemente:

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

O bien, aquí hay una función útil:

fun <T> buildType(): Type {
    return object : TypeToken<ArrayList<T>>() {}.type
}

Entonces, para usar:

val type = buildType<YourMagicObject>()

Quiero añadir una posibilidad más. Si no desea usar TypeToken y desea convertir la matriz de objetos json en una ArrayList, puede proceder de la siguiente manera:

Si su estructura json es como:

{

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

}

Y su estructura de clases es como:

public class ClassName implements Parcelable {

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

Entonces puedes analizarlo como:

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

Ahora puede acceder a cada elemento del objeto className.

Desde Gson 2.8, podemos crear la función util como

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

Ejemplo usando

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

Me gustó la respuesta de kays1 pero no pude implementarla. Así que construí mi propia versión usando su concepto.

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

Uso:

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

En mi caso la respuesta de @uncaught_exceptions no funcionó, tuve que usar List.class en lugar de java.lang.reflect.Type:

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

Consulte el ejemplo 2 para la comprensión de la clase 'Type' de Gson.

Ejemplo 1: En este deserilizeResturant usamos Employee[] array y obtenemos los detalles

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

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