Practice Now
JSON
Gson
Java
JSON Parsing
Java Libraries

JSON parsing using Gson for Java

Interview Questions practice on Codemia

Over 8,000 real interview questions from top companies, searchable by company and role.

Browse interview questions
Java

JSON (JavaScript Object Notation) is a lightweight data interchange format that is easy for both humans and machines to read and write. Java developers frequently interact with JSON data, and there are several libraries available for parsing JSON in Java. One of the most popular libraries is Gson, developed by Google. Gson allows for the serialization and deserialization of Java objects to and from JSON.

Gson Basics

Gson offers several features:

  • It is open source.
  • Simple and straightforward API.
  • Efficient parser and generator.
  • Highly customizable for complex parsing requirements.

To use Gson, you first need to include it in your project. If you're using Maven, you can add the following dependency to your pom.xml:

xml
1<dependency>
2    <groupId>com.google.code.gson</groupId>
3    <artifactId>gson</artifactId>
4    <version>2.8.9</version>
5</dependency>

If you're not using Maven, you can download the latest Gson JAR from the Maven Central Repository and add it to your project's classpath.

Parsing JSON into Java Objects

The primary class for working with Gson is Gson. You typically create a Gson object and call one of its methods, such as fromJson and toJson, to parse JSON.

Example: Parsing a Simple JSON String

Suppose you have a JSON string representing a simple user object:

json
1{
2    "id": 1,
3    "name": "John Doe",
4    "email": "[email protected]"
5}

You can parse this JSON into a Java object as follows:

  1. Create a Java class that represents this JSON structure:
java
1   public class User {
2       private int id;
3       private String name;
4       private String email;
5
6       // Getters and setters
7   }
  1. Use Gson to parse the JSON string:
java
1   import com.google.gson.Gson;
2
3   public class JsonParserExample {
4       public static void main(String[] args) {
5           String jsonString = "{\"id\":1,\"name\":\"John Doe\",\"email\":\"[email protected]\"}";
6           Gson gson = new Gson();
7           User user = gson.fromJson(jsonString, User.class);
8
9           System.out.println("ID: " + user.getId());
10           System.out.println("Name: " + user.getName());
11           System.out.println("Email: " + user.getEmail());
12       }
13   }

Parsing JSON Arrays

If you want to parse JSON arrays, Gson makes it easy with TypeToken. Assume your JSON looks like this:

json
1[
2    {"id": 1, "name": "John Doe", "email": "[email protected]"},
3    {"id": 2, "name": "Jane Doe", "email": "[email protected]"}
4]

To parse this into a list of User objects:

java
1import com.google.gson.Gson;
2import com.google.gson.reflect.TypeToken;
3import java.lang.reflect.Type;
4import java.util.List;
5
6public class JsonArrayExample {
7    public static void main(String[] args) {
8        String jsonArray = "[{\"id\":1,\"name\":\"John Doe\",\"email\":\"[email protected]\"}," +
9                           "{\"id\":2,\"name\":\"Jane Doe\",\"email\":\"[email protected]\"}]";
10
11        Gson gson = new Gson();
12        Type userListType = new TypeToken<List<User>>(){}.getType();
13        List<User> userList = gson.fromJson(jsonArray, userListType);
14
15        for (User user : userList) {
16            System.out.println("ID: " + user.getId() + "\nName: " + user.getName() + "\nEmail: " + user.getEmail());
17        }
18    }
19}

Custom Serialization and Deserialization

Gson has a default behavior for serializing and deserializing JSON data, but when you have special requirements, you can create custom serializers and deserializers.

Custom Deserializer

For example, consider a scenario where your JSON dates are not in the standard format. You might have:

json
{"id": 1, "name": "John Doe", "registeredDate": "30-09-2023"}

Here's how you can handle this:

  1. Create a custom deserializer:
java
1   import com.google.gson.*;
2   import java.lang.reflect.Type;
3   import java.text.SimpleDateFormat;
4   import java.util.Date;
5
6   public class DateDeserializer implements JsonDeserializer<Date> {
7       private static final String DATE_FORMAT = "dd-MM-yyyy";
8
9       @Override
10       public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
11               throws JsonParseException {
12           try {
13               return new SimpleDateFormat(DATE_FORMAT).parse(json.getAsString());
14           } catch (Exception e) {
15               throw new JsonParseException(e);
16           }
17       }
18   }
  1. Register and use the custom deserializer:
java
1   import com.google.gson.Gson;
2   import com.google.gson.GsonBuilder;
3   import java.util.Date;
4
5   public class CustomDeserializerExample {
6       public static void main(String[] args) {
7           String jsonString = "{\"id\":1,\"name\":\"John Doe\",\"registeredDate\":\"30-09-2023\"}";
8
9           GsonBuilder gsonBuilder = new GsonBuilder();
10           gsonBuilder.registerTypeAdapter(Date.class, new DateDeserializer());
11           Gson gson = gsonBuilder.create();
12
13           UserWithDate user = gson.fromJson(jsonString, UserWithDate.class);
14           System.out.println("Registered Date: " + user.getRegisteredDate());
15       }
16   }
17
18   class UserWithDate {
19       private int id;
20       private String name;
21       private Date registeredDate;
22
23       // Getters and setters
24   }

Performance Considerations

Gson is efficient and can be used for most JSON parsing tasks; however, if you experience performance issues with extremely large datasets, consider alternatives like Jackson, which might offer better performance tuning options.

Gson vs. Other Libraries

Below is a comparison of some key features of Gson and other JSON libraries:

FeatureGsonJacksonJSON.simple
Open SourceYesYesYes
JSON to POJOYesYesNo
AnnotationsYesYesNo
Custom ParsingYesYesLimited
Data BindingYesYesNo
PerformanceModerateHighLow
Learning CurveEasyModerateEasy

Conclusion

Gson is a robust and flexible library for handling JSON in Java. It provides an intuitive API, flexible parsing and serialization, and integrates well into Java applications. While it meets most JSON parsing needs, you might need to explore its extensions or alternatives as your requirements expand.

Remember that while JSON parsing is a powerful tool, careful design of your data structures and error handling logic will lead to more maintainable and reliable applications.

Related reading
Course
Intermediate
27 lessons
14 hours
OOD Fundamentals

Master object-oriented design from first principles, SOLID, design patterns, and classic interview problems with hands-on coding.

View the course
Track what you have practised

A free account saves your progress, solutions and study plan across every problem on Codemia.

Interview Questions practice on Codemia

Over 8,000 real interview questions from top companies, searchable by company and role.

Browse interview questions
Codemia
© 2026 Codemia
Resources
Legal
Social
All Rights Reserved.