Convert JSON Array to Java List

1. Introduction

JSON is a popular data interchange format for transferring data between a server and a client. However, in many cases, we may need to convert a JSON array to a Java List object for further processing or data manipulation.

In this tutorial, we’ll compare different approaches to achieving this conversion using two popular JSON libraries in Java – Gson and Jackson.

2. Using the Gson Library

Gson is a widely-used JSON library for serializing and deserializing Java objects to and from JSON. It offers a simple method to change a JSON array into a List object.

2.1. Gson Maven Dependency

We need to add the Gson library to the project dependencies:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.11.0</version>
</dependency>

2.2. Convert JSON Array to Java List

In this section, we’ll discuss how to convert a JSON array to a List using Gson.

Let’s consider an example of a JSON array:

[
{\"id\":1,\"name\":\"Icecream\",\"description\":\"Sweet and cold\"},
{\"id\":2,\"name\":\"Apple\",\"description\":\"Red and sweet\"},
{\"id\":3,\"name\":\"Carrot\",\"description\":\"Good for eyes\"}
];

The above JSON array represents a List of Product class:

public class Product {
    private int id;
    private String name;
    private String description;

    public Product(int id, String name, String description) {
        this.id = id;
        this.name = name;
        this.description = description;
    }
    // getter and setter
}

Now that we have the JSON array, let’s try to understand its conversion to a List:

@Test
public void whenUsingGsonLibrary_thenCompareTwoProducts() {
    Gson gson = new Gson();
    Type listType = new TypeToken<List<Product>>() {}.getType();

    List<Product> gsonList = gson.fromJson(jsonArray, listType);
    Assert.assertEquals(1, gsonList.get(0).getId());
    Assert.assertEquals("Sweet and cold", gsonList.get(0).getDescription());
    Assert.assertEquals("Icecream", gsonList.get(0).getName());
}

First, we need to create an instance of the Gson class, which provides methods for JSON serialization and deserialization.

We can specify the type of the target List using the TypeToken class. In the above example, we’ve defined the target type as List<Product>.

Then, we use the fromJson() method of the Gson object to convert the JSON array String to a List.

Since we’ve converted JSON array to a List, let’s also try to analyze the assertion. In the assertion, we’re comparing a particular field, such as ID or description, in the String JSON array to the converted gsonList, which represents a List of Product class. 

3. Using Jackson Library

Jackson is another widely-used JSON library for Java. In this section, we’ll discuss how to convert a JSON array to a List using the Jackson library.

3.1. Jackson Maven Dependency

We need to add the below Jackson library to the project dependencies:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

3.2. Convert JSON Array to Java List

In this section, we’ll discuss how to convert a JSON array to a List using Jackson:

@Test
public void whenUsingJacksonLibrary_thenCompareTwoProducts() throws JsonProcessingException {

    // The jsonArray is the same JSON array from the above example
    ObjectMapper objectMapper = new ObjectMapper();
    TypeReference<List<Product>> jacksonTypeReference = new TypeReference<List<Product>>() {};

    List<Product> jacksonList = objectMapper.readValue(jsonArray, jacksonTypeReference);
    Assert.assertEquals(1, jacksonList.get(0).getId());
    Assert.assertEquals("Sweet and cold", jacksonList.get(0).getDescription());
    Assert.assertEquals("Icecream", jacksonList.get(0).getName());
}

We create an instance of the ObjectMapper class, which serves as the core class of the Jackson library for data manipulation.

We can specify the type of the target List using the TypeReference class. In the above example, we’ve defined the target type as List<Product>.

Then, we use the readValue() method of the ObjectMapper object to convert the JSON array String to a List.

Similar to the assertion discussed previously, finally, we compare a specific field from the String JSON array to the jacksonList corresponding field.

4. Conclusion

In this article, we discussed how to convert a JSON array to a Java List using two popular libraries: Gson and Jackson.

Gson provides a straightforward approach, whereas Jackson offers advanced features and high performance. The choice of Gson vs. Jackson depends on specific project requirements and preferences.