How to Parse JSON Array with Gson

When you need to parse a JSON array using the Gson library in Java, the typical steps involve first defining a Java class that matches the JSON data structure, then using the Gson object to convert the JSON string into a collection of Java objects.

Here is a specific example illustrating how to handle this process.

Assume we have the following JSON array:

json
[
    {
        "name": "Alice",
        "age": 25
    },
    {
        "name": "Bob",
        "age": 30
    }
]

First, we need to define a Java class to map the structure of this JSON object. For example:

java
public class Person {
    private String name;
    private int age;

    // Constructor
    public Person() {}

    // Omitted getter and setter methods
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Then, we can use the Gson library to parse this JSON array. Here are the parsing steps:

java
import com.google.gson.reflect.TypeToken;
import com.google.gson.Gson;
import java.lang.reflect.Type;
import java.util.List;

public class JsonParser {
    public static void main(String[] args) {
        String json = "[{\"name\":\"Alice\",\"age\":25},{\"name\":\"Bob\",\"age\":30}]";
        Gson gson = new Gson();
        
        Type userListType = new TypeToken<List<Person>>(){}.getType();
        List<Person> userList = gson.fromJson(json, userListType);

        for (Person user : userList) {
            System.out.println("Name: " + user.getName() + ", Age: " + user.getAge());
        }
    }
}

In this example, we use TypeToken to obtain a Type instance representing List<Person>, which is necessary because Java generics are erased at runtime. By passing this type instance, Gson can correctly parse the JSON array into a List<Person> object.

This is the basic process and example for using Gson to parse JSON arrays. This method can easily be extended to more complex JSON structures and larger data sets.