How to Deserialize a JSON Array of Objects with Jackson in Java

By the end of this page, you will understand how Jackson deserializes JSON arrays of objects into Java arrays and lists, why List<MyClass>.class does not work directly, and how to use TypeReference or arrays like MyClass[] in practical Java code.

Jackson converts JSON into Java objects by matching JSON structure to Java types.

For a single JSON object, the mapping is straightforward because the target type is a concrete class such as MyClass.class.

For a JSON array, Jackson needs to know two things:

• that the input is a collection
• what the element type inside that collection is

This matters because Java uses type erasure for generics. At runtime, List<MyClass> becomes just List, so Jackson cannot infer MyClass from List<MyClass>.class because that syntax does not exist.

That is why Jackson provides two common solutions:

1. Deserialize into an array:

MyClass[] items = objectMapper.readValue(json, MyClass[].class);

1. Deserialize into a generic collection using TypeReference:

List<MyClass> items = objectMapper.readValue(json, new TypeReference<List<MyClass>>() {});

This concept matters in real programming because APIs often return arrays of objects:

• lists of users
• orders
• products
• log entries
• search results

Think of Jackson like a shipping clerk unpacking boxes.

• A single object is one box labeled MyClass
• A JSON array is a crate containing many boxes

If you say:

• MyClass.class → Jackson knows each item is one MyClass
• MyClass[].class → Jackson knows it is a crate of MyClass boxes
• new TypeReference<List<MyClass>>() {} → Jackson knows it is a list where every item must be a MyClass

Without that extra type information, Jackson only sees a generic container and does not know what kind of objects belong inside it.

The two most common ways to deserialize a JSON array of objects are shown below.

Option 1: Read into an array

import com.fasterxml.jackson.databind.ObjectMapper;

String json = """
[
  { "id": "junk", "stuff": "things" },
  { "id": "spam", "stuff": "eggs" }
]
""";

ObjectMapper objectMapper = new ObjectMapper();
MyClass[] entries = objectMapper.readValue(json, MyClass[].class);

This is simple and efficient. You get a Java array.

Option 2: Read into a List

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;

String json = """
[
  { "id": "junk", "stuff": "things" },
  { "id": "spam", "stuff": "eggs" }
]
""";

ObjectMapper objectMapper = new ObjectMapper();
List<MyClass> entries = objectMapper.readValue(json, new TypeReference<List<MyClass>>() {});

This is the most common solution when you want a List<MyClass> directly.

Example class

Consider this code:

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;

String json = """
[
  { "id": "junk", "stuff": "things" },
  { "id": "spam", "stuff": "eggs" }
]
""";

ObjectMapper objectMapper = new ObjectMapper();
List<MyClass> entries = objectMapper.readValue(json, new TypeReference<List<MyClass>>() {});

Here is what happens step by step:

1. json contains a JSON array with two objects.

2. new ObjectMapper() creates the Jackson mapper responsible for parsing JSON.

3. readValue(...) starts reading the JSON string.

4. Jackson sees new TypeReference<List<MyClass>>() {} and learns:

   • the outer type is a List
   • each element inside the list must be a MyClass

5. Jackson reads the first JSON object:

JSON arrays of objects appear everywhere in real applications.

API responses

A REST API often returns lists like:

• users
• products
• messages
• invoices

Example:

[
  { "id": 1, "name": "Laptop" },
  { "id": 2, "name": "Keyboard" }
]

You would deserialize this into List<Product>.

Configuration files

Some applications store repeated configuration items as arrays:

[
  { "host": "server1", "port": 8080 
       

In real projects, developers usually do more than just call readValue.

Common pattern: deserialize directly to a list

List<MyClass> entries = objectMapper.readValue(
    json,
    new TypeReference<List<MyClass>>() {}
);

This is common in service classes and HTTP clients.

Validation after deserialization

After mapping, code often validates the result:

if (entries.isEmpty()) {
    throw new IllegalArgumentException("No entries found");
}

Guard clauses for null or bad input

if (json == null || json.isBlank()) {
    return List.of();
}

Reading from files or streams

Jackson is often used with files, request bodies, or input streams instead of plain strings:

List<MyClass> entries = objectMapper.readValue(file, new TypeReference<List<MyClass>>() {});

Error handling

Developers usually catch parsing exceptions and convert them into application-level errors:

Here are common beginner mistakes when deserializing JSON arrays with Jackson.

Mistake 1: Trying to use List<MyClass>.class

This is invalid Java.

// Broken
List<MyClass> entries = objectMapper.readValue(json, List<MyClass>.class);

Why it fails

Java does not allow .class on a parameterized generic type.

Fix

Use TypeReference:

List<MyClass> entries = objectMapper.readValue(json, new TypeReference<List<MyClass>>() {});

Mistake 2: Using List.class and expecting typed objects

// Broken for strongly typed mapping
List<MyClass> entries = objectMapper.readValue(json, List.class);

Why it fails

Jackson can create a raw list, but the items may become generic maps such as LinkedHashMap instead of MyClass objects.

Fix

Provide the element type:

Quick syntax

Single object

MyClass item = objectMapper.readValue(json, MyClass.class);

Array of objects

MyClass[] items = objectMapper.readValue(json, MyClass[].class);

List of objects

List<MyClass> items = objectMapper.readValue(json, new TypeReference<List<MyClass>>() {});

Rules to remember

• MyClass.class is for one JSON object.
• MyClass[].class is for a JSON array.
• List<MyClass>.class is not valid Java.
• Use TypeReference<List<MyClass>>() {} for generic collections.
• List.class loses element type information.

Common requirements for Jackson POJOs

• No-argument constructor
• Matching field/property names, or use @JsonProperty
• Getters/setters in typical Java bean style

Typical error source

If the JSON shape does not match the Java target type, deserialization fails.

How do I deserialize a JSON array into List<MyClass> with Jackson?

Use:

List<MyClass> items = objectMapper.readValue(json, new TypeReference<List<MyClass>>() {});

Why can't I use List<MyClass>.class in Java?

Because Java generics use type erasure, and parameterized types do not have a .class literal.

Can I deserialize into MyClass[] instead of a list?

Yes.

MyClass[] items = objectMapper.readValue(json, MyClass[].class);

What happens if I use List.class?

Jackson usually creates a raw list whose elements are generic maps rather than MyClass objects.

Does my class need getters and setters?

Usually yes for standard Jackson bean mapping, along with a no-argument constructor, unless you use other supported mapping styles.

How do I deserialize a JSON array from a file?

Use the same pattern with a file instead of a string:

List<MyClass> items = objectMapper.readValue(file, new <List<MyClass>>() {});

• JSON deserialization — The broader process of converting JSON into Java objects.
• Jackson ObjectMapper — The main class used to read and write JSON.
• Java generics — Explains why List<MyClass> needs special handling at runtime.
• Type erasure — The reason generic type information is not fully available at runtime.
• POJO mapping — Jackson commonly maps JSON into plain Java objects.
• @JsonProperty — Useful when JSON field names and Java property names differ.
• Serialization — The opposite process: converting Java objects into JSON.
• Wrapper response objects — Important when arrays are nested inside outer API response objects.