Deserialize a List<T> object with Gson

Another way is to use an array as a type, e.g.:

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

This way you avoid all the hassle with the Type object, and if you really need a list you can always convert the array to a list by:

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

IMHO this is much more readable.

And to make it be an actual list (that can be modified, see limitations of Arrays.asList()) then just do the following:

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

Since Gson 2.8, we can create util function like this:

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

Example usage:

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

Refer to this post. Java Type Generic as Argument for GSON

I have better solution for this. Here's the wrapper class for list so the wrapper can store the exactly type of 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; } } 

And then, the code can be simple:

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

Wep, another way to achieve the same result. We use it for its readability.

Instead of doing this hard-to-read sentence:

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

Create a empty class that extends a List of your object:

public class YourClassList extends ArrayList<YourClass> {} 

And use it when parsing the JSON:

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

For Kotlin simply:

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

or, here is a useful function:

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

Then, to use:

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

Example:

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

As it answers my original question, I have accepted doc_180's answer, but if someone runs into this problem again, I will answer the 2nd half of my question as well:

The NullPointerError I described had nothing to do with the List itself, but with its content!

The "MyClass" class didn't have a "no args" constructor, and neither had its superclass one. Once I added a simple "MyClass()" constructor to MyClass and its superclass, everything worked fine, including the List serialization and deserialization as suggested by doc_180.

Here is a solution that works with a dynamically defined type. The trick is creating the proper type of of array using 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; } 

I want to add for one more possibility. If you don't want to use TypeToken and want to convert json objects array to an ArrayList, then you can proceed like this:

If your json structure is like:

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

}

and your class structure is like:

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

then you can parse it like:

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

Now you can access each element of className object.

Refer to example 2 for 'Type' class understanding of Gson.

Example 1: In this deserilizeResturant we used Employee[] array and get the details

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

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

using Kotlin, you can get generic MutableList type for all custom Serializable Types

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

you can call this function

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

In My case @uncaught_exceptions's answer didn't work, I had to use List.class instead of java.lang.reflect.Type:

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

I have created GsonUtils lib for this case. I add this into maven central repository.

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

I liked the answer from kays1 but I couldn't implement it. So I built my own version using his concept.

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

Usage:

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

Kotlin and extension version of @Linh's answer

fun <T> Gson.listFromJson(json: String, clazz: Class<T>): List<T> { val typeOfT: Type = TypeToken.getParameterized(MutableList::class.java, clazz).type return fromJson(json, typeOfT) } 

Usage

val list: List<YourClass> = Gson().listFromJson(it, YouClass::class.java)