How can I make Gson.fromJson() return an empty list instead of null for a field with a null value?

I am using Gson to deserialize a bunch of objects, some of which are more complex and some "lightweight".

I am in a bit of a cunundrum over here, as I have been expecting another behaviour from GSON.fromJson() when reading a field with null value. More precisely, looking at this example

public class TestApplication{
	@Data
	@NoArgsConstructor
	public class User{

		private String userName;
		@SerializedName(value = "eMailAddress")
		private String email;
		private final List<Object> list = new ArrayList<>();

	}

	public static void main(String[] args) {
		String x = "{\n" + "\"userName\": \"test\""
			+ ",\n" + "\"eMailAddress\": \"dan@gmail.com\""
			+ ",\n" + "\"list\": null\n"
			+ "}";

		User from = new Gson().fromJson(x, User.class);
		System.out.println(from);
	}

}

This prints:

TestApplication.User(userName=test, email=dan@gmail.com, list=null)

I was expecting the output list to be empty (list=[]) and not null.

Can I do anything to achieve the behaviour I need? My application uses lists of objects and it is not feasable to register a typeAdapter for each of them.

How would I go about writing a custom deserializer? This next example would be simple enough if it were to work:

	class CollectionDeserializer implements JsonDeserializer<Collection<?>> {

		public Collection<?> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {

			return ObjectUtils.isEmpty(json) ? new ArrayList<>() : new Gson().fromJson(json, Collection.class);
		}

	}

What I have tried:

• implementing a customer deserializer ( above ) with no success.
• @JsonSetter(nulls= Nulls.SKIP) annotation with no effect on the Gson parsing.

Your JSON string is explicitly saying that this list is null, so I'm not sure why you expected it to be empty in the first place. For an empty string, the JSON string should be [].

Nevertheless, if you still want to convert null lists to empty lists in your custom deserializer, the answer is simple. Your custom deserializer is not working because it's testing the the json element being null or empty. It's neither of those: it's a value that represents a null element. Use JsonElement.isJsonNull:

class CollectionDeserializer implements JsonDeserializer<Collection<?>> {
    public Collection<?> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        return json.isJsonNull() ? Collections.emptyList() : ...;
    }
}

It can be done with Jackson, and without explicitly set the field to null:

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.List;

public class TestApplication{
    @Data
    @NoArgsConstructor
    public static class User{

        private String userName;
        @JsonProperty("eMailAddress")
        private String email;
        private final List<Object> list = new ArrayList<>();

    }

    public static void main(String[] args) throws JsonProcessingException {
        String x = "{\n" + "\"userName\": \"test\""
                + ",\n" + "\"eMailAddress\": \"dan@gmail.com\""
                + "}";

        ObjectMapper mapper = new ObjectMapper();
        User from = mapper.readValue(x, User.class);

        System.out.println(from);
    }

}

This prints:

TestApplication.User(userName=test, email=dan@gmail.com, list=[])

This can be solved with a custom TypeAdapterFactory:

class NullListToEmptyFactory implements TypeAdapterFactory {
    public static final NullListToEmptyFactory INSTANCE = new NullListToEmptyFactory();

    private NullListToEmptyFactory() {
    }

    @Override
    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
        Class<?> rawType = type.getRawType();

        // Only handle List and ArrayList; let other factories handle different types
        if (rawType != List.class && rawType != ArrayList.class) {
            return null;
        }

        // Delegate which handles deserialization of non-null values, and serialization
        TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
        return new TypeAdapter<T>() {
            @Override
            public void write(JsonWriter out, T value) throws IOException {
                delegate.write(out, value);
            }

            @Override
            public T read(JsonReader in) throws IOException {
                if (in.peek() == JsonToken.NULL) {
                    in.nextNull();

                    // Safe due to check at beginning of `create` method
                    @SuppressWarnings("unchecked")
                    T t = (T) new ArrayList<>();
                    return t;
                } else {
                    return delegate.read(in);
                }
            }
        };
    }
}

You can then register this factory on a GsonBuilder like this:

Gson gson = new GsonBuilder()
    .registerTypeAdapterFactory(NullListToEmptyFactory.INSTANCE)
    .create();

The usage of TypeAdapterFactory has the following advantages:

• It uses TypeAdapter which normally performs better than JsonDeserializer because it directly operates on the JSON stream and does not have to convert it to a JsonElement first
• It allows delegating to the default adapter:
  • There is no need to create a second Gson instance; deserialization will use your existing Gson instance and all of its configuration you made
  • It supports custom element types, for example List<MyClass> because the delegate does all the type resolution work

Important: With any solution you choose for this problem, none of them will handle the case where the field is missing in the JSON data. Gson does not support that very well at the moment, see this feature request. You currently have to explicitly initialize the field with a non-null List (and make sure your class has a no-args constructor; more information), otherwise the field will be null if it is missing in the JSON data.

It can be done with Gson with explicitly set the field to empty list:
Replace:

+ ",\n" + "\"list\": null\n"

With:

+ ",\n" + "\"list\": []\n"

This prints:

TestApplication.User(userName=test, email=null, list=[])

A null list is not the same as an empty list.

You can only use a custom adapter if you want all null arrays to become empty arrays. It's a lot of work. You need the following:

New variant of ArrayTypeAdapter, CollectionTypeAdapterFactory and other setup classes.

Change the following lines of ArrayTypeAdapter

if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}

to

if (in.peek() == JsonToken.NULL) {
in.nextNull();
return Array.newInstance(componentType, 0);
}

Instead of doing this, I recommend that you add an input validator @NotNull or programmatically change the null to [] for specific values after deserialisation