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

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class JsonExample {

    // We'll use these two classes to demonstrate encoding and
    // decoding of custom types below.
    static class Response1 {
        int page;
        String[] fruits;
    }

    // Fields must be public or have getter/setter methods to be serialized/deserialized
    static class Response2 {
        private int page;
        private String[] fruits;

        public int getPage() { return page; }
        public void setPage(int page) { this.page = page; }
        public String[] getFruits() { return fruits; }
        public void setFruits(String[] fruits) { this.fruits = fruits; }
    }

    public static void main(String[] args) {
        Gson gson = new Gson();

        // First we'll look at encoding basic data types to
        // JSON strings. Here are some examples for atomic values.
        System.out.println(gson.toJson(true));
        System.out.println(gson.toJson(1));
        System.out.println(gson.toJson(2.34));
        System.out.println(gson.toJson("gopher"));

        // And here are some for slices and maps, which encode
        // to JSON arrays and objects as you'd expect.
        String[] slcD = {"apple", "peach", "pear"};
        System.out.println(gson.toJson(slcD));

        Map<String, Integer> mapD = new HashMap<>();
        mapD.put("apple", 5);
        mapD.put("lettuce", 7);
        System.out.println(gson.toJson(mapD));

        // The Gson library can automatically encode your
        // custom data types. It will use field names as the JSON keys.
        Response1 res1D = new Response1();
        res1D.page = 1;
        res1D.fruits = new String[]{"apple", "peach", "pear"};
        System.out.println(gson.toJson(res1D));

        // You can use annotations on class fields to customize
        // the encoded JSON key names. Check Gson documentation
        // for more details on this.
        Response2 res2D = new Response2();
        res2D.setPage(1);
        res2D.setFruits(new String[]{"apple", "peach", "pear"});
        System.out.println(gson.toJson(res2D));

        // Now let's look at decoding JSON data into Java
        // objects. Here's an example for a generic data structure.
        String jsonStr = "{\"num\":6.13,\"strs\":[\"a\",\"b\"]}";

        // We need to provide a Type where Gson can put the decoded data.
        // This Map<String, Object> will hold a map of strings to arbitrary data types.
        Type type = new TypeToken<Map<String, Object>>(){}.getType();
        Map<String, Object> dat = gson.fromJson(jsonStr, type);
        System.out.println(dat);

        // To use the values in the decoded map, we'll need to cast them
        // to their appropriate type.
        double num = (Double) dat.get("num");
        System.out.println(num);

        // Accessing nested data requires a series of casts.
        String[] strs = gson.fromJson(gson.toJson(dat.get("strs")), String[].class);
        String str1 = strs[0];
        System.out.println(str1);

        // We can also decode JSON into custom data types.
        // This has the advantages of adding additional
        // type-safety to our programs and eliminating the
        // need for type assertions when accessing the decoded data.
        String str = "{\"page\": 1, \"fruits\": [\"apple\", \"peach\"]}";
        Response2 res = gson.fromJson(str, Response2.class);
        System.out.println(res.getPage());
        System.out.println(res.getFruits()[0]);

        // In the examples above we always used strings as intermediates between
        // the data and JSON representation. We can also write JSON encodings
        // directly to any Writer, like System.out or even HTTP response bodies.
        gson.toJson(mapD, System.out);
    }
}