How To Convert String To Json Object In Java

In Java, you can convert a string to a JSON object using a JSON library such as Jackson or Gson. Create an ObjectMapper instance and use its readTree() method to parse the JSON string into a JsonNode object. We can then access the values of the JSON object using the get() method on the JsonNode object and convert them to the appropriate data types using the asText() and asInt() methods.

Requirements for Converting String To Json Object In Java

There are multiple reasons for converting a string to a JSON object in Java. Some of these reasons include:

1. Parsing JSON data: If you are working with JSON data that is stored in a string format, you will need to convert it to a JSON object to be able to access the data and work with it in your Java application.
2. Sending JSON data to a server: If you need to send JSON data to a server as part of an API request, you will need to convert the data to a JSON object before sending it.
3. Manipulating JSON data: If you need to manipulate JSON data in your Java application, it can be easier to work with the data as a JSON object than as a string.
4. Serializing Java objects to JSON: If you have Java objects that you want to convert to JSON format, you can use a JSON library to serialize the objects to a JSON string and then convert the string to a JSON object.
5. Deserializing JSON data to Java objects: If you receive JSON data from a server and need to convert it to Java objects, you can use a JSON library to deserialize the JSON data to Java objects. To do this, you will first need to convert the JSON data from a string to a JSON object.

Methods for Converting String To Json Object In Java

In Java, you can use following three methods for converting a string to a JSON object, that includes:

1. Using the org.json library
2. Using the Jackson library
3. Using the Gson library

Let us understand all methods in details to know how String is converted to Json object in Java:

Approach 1: Using the org.json library

The org.json library provides a set of classes that represent JSON data structures, such as objects, arrays, and values. It also provides methods for reading and writing JSON data from various input/output sources, such as files, strings, and streams.

Here is the example for better understanding:

Code:

import org.json.JSONObject;
public class StringToJsonExample {
    public static void main(String[] args) {
        String jsonString = "{\"Name\":\"John\"}"; // Example JSON string
        JSONObject json = new JSONObject(jsonString); // Convert the string to a JSON object
        System.out.println(json.toString()); // Print the JSON object
    }
}

Output:

{"Name":"John"}

Explanation of the code:

• Import the JSONObject class from the org.json library.
• Define a JSON string as an example input to convert.
• Create a JSONObject instance and pass in the JSON string as a parameter.
• Print the resulting JSON object using the toString() method.

Approach 2: Using the Jackson library

The Jackson library is a popular Java library for working with JSON data. It provides a set of high-performance classes for parsing, creating, and manipulating JSON data, and is widely used in Java-based web applications, RESTful web services, and other systems that use JSON as a data format.

Look at the example for understanding the implementation:

Code:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class StringToJsonExample {
    public static void main(String[] args) throws Exception {
        String key = "Vehicle"; // Example key
        String value = "Car"; // Example value
        String jsonString = "{\"" + key + "\":\"" + value + "\"}"; // Create the JSON string
        ObjectMapper mapper = new ObjectMapper(); // Create an ObjectMapper instance
        JsonNode json = mapper.readTree(jsonString); // Convert the string to a JsonNode
        System.out.println(json.toString()); // Print the JSON object
    }
}

Output:

{"Vehicle":"Car"}

Explanation of the code:

• Import the ObjectMapper and JsonNode classes from the Jackson library.
• Define the key and value of the JSON object as separate strings.
• Create a JSON string with the key-value pair.
• Create an ObjectMapper instance to convert the JSON string to a JsonNode.
• Use the readTree() method of the ObjectMapper to convert the JSON string to a JsonNode.
• Print the resulting JSON object using the toString() method.

Approach 3: Using the Gson library

The Gson library is a Java library for working with JSON data. It provides a simple and easy-to-use API for parsing, creating, and manipulating JSON data, and is widely used in Java-based web applications, RESTful web services, and other systems that use JSON as a data format.

It is an example of using the Gson Library for converting string to json object in Java:

Code:

import com.google.gson.Gson;
import com.google.gson.JsonObject;

public class StringToJsonExample {
    public static void main(String[] args) {
        String key = "Domain"; // Example key
        String value = "Science"; // Example value
        JsonObject json = new JsonObject(); // Create an empty JsonObject
        json.addProperty(key, value); // Add the key-value pair to the JsonObject
        System.out.println(json.toString()); // Print the JSON object
    }
}

Output:

{"Domain":"Science"}

Explanation of the code:

• Import the Gson and JsonObject classes from the Gson library.
• Define the key and value of the JSON object as separate strings.
• Create an empty JsonObject instance.
• Add the key-value pair to the JSON object using the addProperty() method.
• Print the resulting JSON object using the toString() method.

Best Approach for Converting String To Json Object In Java

Jackson librarycan be considered as the best approach for convertingString to Json Object because of following reasons:

• High performance: The Jackson library is known for its high performance and low memory footprint, making it a popular choice for handling large amounts of JSON data.
• Rich feature set: Jackson provides a wide range of features for working with JSON data, including support for streaming, tree models, and databinding. This makes it a versatile and flexible tool for many use cases.
• Easy to use: Jackson’s API is simple and easy to use, with intuitive methods for parsing and creating JSON objects.
• Active development: The Jackson library is under active development, with regular updates and improvements being made to the codebase. This ensures that the library remains up-to-date with the latest best practices and standards for working with JSON data.
• Large community: Jackson has a large and active community of users and contributors, which means that it’s easy to find resources, examples, and support when using the library.

Sample Problems for Converting String To Json Object In Java

Sample Problem 1

Given a JSON string with a nested array of objects, how would you use the Jackson library to parse it and extract a specific value from each object in the array, and then store it in a list of Java objects?

Solution:

• The code demonstrates how to use the Jackson library to parse a JSON string with a nested array of objects, extract a specific value from each object in the array, and then store it in a list of Java objects.
• The code starts by creating a JSON string that contains an array of people objects with their name and age values.
• The Jackson ObjectMapper is then created and used to parse the JSON string and extract the array of people objects using the readValue() method.
• A custom PeopleList class is created to represent the list of people objects, with a getter and setter for the people property.
• A custom Person class is also created to represent a person object, with getters and setters for the name and age properties.
• An empty list is then created to store the people objects.
• A for loop is used to iterate through each person object in the list, extract the name value, and print it to the console.
• The person object is then added to the list of people using the add() method.
• Finally, the list of people objects is printed to the console using the toString() method.

The following dependencies are required in the code:

• com.fasterxml.jackson.databind.ObjectMapper – This is the main Jackson library used for parsing and creating JSON data.
• java.util.ArrayList – This is a built-in Java class used to create an empty list of people objects.
• java.util.List – This is a built-in Java interface used to define the list of people objects.

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.List;
public class JacksonExample {
    public static void main(String[] args) {
        // JSON string with a nested array of objects
        String jsonString = "{\"people\":[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]}";
        try {
            // create an instance of the Jackson ObjectMapper
            ObjectMapper mapper = new ObjectMapper();
            // parse the JSON string and extract the array of people objects
            PeopleList peopleList = mapper.readValue(jsonString, PeopleList.class);
            // create an empty list to store the people objects
            List<Person> people = new ArrayList<>();
            // iterate through each person object in the list and extract the name value
            for (Person person : peopleList.getPeople()) {
                String name = person.getName();
                System.out.println("Name: " + name);
                // add the person object to the list of people
                people.add(person);
            }
            // print the list of people objects
            System.out.println("People List: " + people.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class PeopleList {
    private List<Person> people;
    public List<Person> getPeople() {
        return people;
    }
    public void setPeople(List<Person> people) {
        this.people = people;
    }
}
class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

Output:

Name: John
Name: Jane
People List: [{name=John, age=30}, {name=Jane, age=25}]

Sample Problem 2

Given a JSON string with a nested object containing arrays, how would you use the Gson library to parse it and extract all the values in a specific array and store them in a list of Java objects?

Solution:

• The code shows how to use the Gson library to parse a JSON string with a nested object containing arrays, extract all the values in a specific array, and store them in a list of Java objects.
• The code starts by creating a JSON string that contains an object with two arrays of students, each containing their name and age values.
• The Gson library is then created and used to parse the JSON string and extract the object containing the arrays of students using the fromJson() method.
• An empty list is then created to store the student objects.
• Two nested for loops are used to iterate through each array of students, extract the student objects using the fromJson() method, and add them to the list of students using the add() method.
• Finally, the list of student objects is printed to the console using the toString() method.

Dependencies in the program:

• Gson library – for JSON parsing and serialization.
• java.util.ArrayList -It is a built-in Java class used to create an empty list of people objects.
• java.util.List – This is a built-in Java interface used to define the list of people objects.

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import java.util.ArrayList;
import java.util.List;
public class GsonExample {
    public static void main(String[] args) {
        // JSON string with a nested object containing arrays
        String jsonString = "{\"students\":{\"classA\":[{\"name\":\"John\",\"age\":16},{\"name\":\"Jane\",\"age\":15}],\"classB\":[{\"name\":\"David\",\"age\":17},{\"name\":\"Lily\",\"age\":16}]}}";
        try {
            // create an instance of the Gson library
            Gson gson = new Gson();
            // parse the JSON string and extract the object containing the arrays of students
            JsonObject jsonObject = gson.fromJson(jsonString, JsonObject.class).getAsJsonObject("students");
            // create an empty list to store the student objects
            List<Student> students = new ArrayList<>();
            // iterate through each array of students, extract the student objects, and add them to the list of students
            for (String className : jsonObject.keySet()) {
                JsonArray studentsArray = jsonObject.getAsJsonArray(className);
                for (JsonElement studentElement : studentsArray) {
                    Student student = gson.fromJson(studentElement, Student.class);
                    students.add(student);
                }
            }
            // print the list of student objects
            System.out.println("Student List: " + students.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Student {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Output:

Student List: [Student{name='John', age=16}, Student{name='Jane', age=15}, Student{name='David', age=17}, Student{name='Lily', age=16}]

Sample Problem 3

Given a JSON string with a complex object containing arrays and nested objects, how would you use the org.json library to parse it and extract a specific value from a nested object, and then store it in a Java object?

Solution:

• The code includes the use of the org.json library to parse a JSON string with a complex object containing arrays and nested objects, extract a specific value from a nested object, and then store it in a Java object.
• The code starts by creating a JSON string that contains an object with an array of students, each containing their name, age, and grades values.
• The JSONObject is created from the JSON string.
• The array of students is then extracted from the JSONObject using the getJSONArray() method.
• An empty Student object is created to store the specific value from the nested object.
• A for loop is used to iterate through each student in the array of students, extract the specific value from the nested object using the getJSONObject() and getInt() methods, and store it in the Student object using the setName(), setAge(), and setMathGrade() methods.
• Finally, the Student object is printed to the console using the toString() method.

The dependencies in the program are:

org.json.JSONArray: This is a class from the org.json package, which is used to represent an ordered sequence of values in JSON (similar to a Java array).

org.json.JSONObject: This is a class from the org.json package, which is used to represent a JSON object.

import org.json.JSONArray;
import org.json.JSONObject;
public class OrgJsonExample {
    public static void main(String[] args) {
        // JSON string with a complex object containing arrays and nested objects
        String jsonString = "{\"students\":[{\"name\":\"John\",\"age\":16,\"grades\":{\"math\":90,\"english\":85}},{\"name\":\"Jane\",\"age\":15,\"grades\":{\"math\":85,\"english\":90}}]}";
        try {
            // create a JSONObject from the JSON string
            JSONObject jsonObject = new JSONObject(jsonString);
            // extract the array of students from the JSONObject
            JSONArray studentsArray = jsonObject.getJSONArray("students");
            // create an empty Student object to store the specific value from the nested object
            Student student = new Student();
            // extract the specific value from the nested object for each student and store it in the Student object
            for (int i = 0; i < studentsArray.length(); i++) {
                JSONObject studentObject = studentsArray.getJSONObject(i);
                int mathGrade = studentObject.getJSONObject("grades").getInt("math");
                if (mathGrade >= 90) {
                    student.setName(studentObject.getString("name"));
                    student.setAge(studentObject.getInt("age"));
                    student.setMathGrade(mathGrade);
                }
            }
            // print the Student object
            System.out.println("Student: " + student.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Student {
    private String name;
    private int age;
    private int mathGrade;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getMathGrade() {
        return mathGrade;
    }
    public void setMathGrade(int mathGrade) {
        this.mathGrade = mathGrade;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", mathGrade=" + mathGrade +
                '}';
    }
}

Output:

Student: Student{name='John', age=16, mathGrade=90}

Conclusion

In conclusion, converting a JSON string to a Java object is a common requirement in modern programming, and there are several libraries available in Java that can be used to achieve this. The most popular libraries for this task are Gson, Jackson, and org.json.

Jackson is easy to use and provides a simple way to convert a JSON string to a Java object. Jackson is efficient and provides excellent performance with large JSON files, making it the best choice for applications that need to parse large data sets. Org.json is a lightweight library with minimal dependencies and provides a simple API for parsing JSON strings.

24×7 Live Java Homework Help From Expert Tutors! Get Help Now

Author

Shubham Kumar