1. Overview
Gson is a Java library that allows us to convert Java Objects into a JSON representation. We can also use it the other way around, to convert a JSON string to an equivalent Java object.
In this quick tutorial, we’ll find out how to save various Java data types as a JSON in a file.
2. Maven Dependencies
First of all, we need to add the Gson dependency in pom.xml. This is available in Maven Central:
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.10.1</version>
</dependency>
3. Saving Data to a JSON File
We’ll use the toJson(Object src, Appendable writer) method from the Gson class to convert a Java data type into JSON and store it in a file. The Gson() constructor creates a Gson object with default configuration:
Gson gson = new Gson();
Now, we can call toJson() to convert and store Java objects.
Let’s explore some examples with different data types in Java.
3.1. Primitives
Saving primitives to a JSON file is pretty straight-forward using GSON:
gson.toJson(123.45, new FileWriter(filePath));
Here, filePath denotes the location of the file. The file output will simply contain the primitive value:
123.45
3.2. Custom Objects
Likewise, we can store objects as JSON.
First, we’ll create a simple User class:
public class User {
private int id;
private String name;
private transient String nationality;
public User(int id, String name, String nationality) {
this.id = id;
this.name = name;
this.nationality = nationality;
}
public User(int id, String name) {
this(id, name, null);
}
}
Now, we’ll store a User object as a JSON:
User user = new User(1, "Tom Smith", "American");
gson.toJson(user, new FileWriter(filePath));
The file output will be:
{"id":1,"name":"Tom"}
If a field is marked transient, it’s ignored by default and not included in the JSON serialization or deserialization. As a result, the nationality field isn’t present in the JSON output.
Also by default, Gson omits null fields during serialization. So if we consider this example:
gson.toJson(new User(1, null, "Unknown"), new FileWriter(filePath));
the file output will be:
{"id":1}
We’ll see how to include null fields in serialization later.
3.3. Collections
We can store a collection of objects in a similar manner:
User[] users = new User[] { new User(1, "Mike"), new User(2, "Tom") };
gson.toJson(users, new FileWriter(filePath));
In this case, the file output will be an array of User objects:
[{"id":1,"name":"Mike"},{"id":2,"name":"Tom"}]
4. Using GsonBuilder
In order to tweak the default Gson configuration settings, we can utilize the GsonBuilder class.
This class follows the builder pattern, and it’s typically used by first invoking various configuration methods to set desired options, and finally calling the create() method:
Gson gson = new GsonBuilder()
.setPrettyPrinting()
.create();
Here, we’re setting the pretty print option which is by default set to false. Similarly, to include null values in serialization, we can call serializeNulls(). The available options are listed here.
5. Conclusion
In this quick article, we got an understanding of how to serialize various Java data types into a JSON file. To explore various articles on JSON, have a look at our other tutorials on this topic.
As always, the code snippets are available in this GitHub repository.
