How to convert JSONObject to JSONArray in java (3 Best Approaches)

JSONObject is a Java class that simulates a JSON object. JSON (short for JavaScript Object Notation) is a simple data exchange format that is simple for machines to parse and generate as well as for humans to read and write.

In Java, JSONArray is a class that represents an ordered collection of values in the JSON format.It offers ways to add, remove, and retrieve values as well as ways to turn an array into a JSON string. It is a component of Java’s org.json package.

In Java, it is not possible to convert a JSONObject directly to a JSONArray because they are different data structures. The values of a JSONObject can, however, be taken out and used to build a new JSONArray.

It should be noted that the JSONArray’s elements and JSONObject’s keys may not appear in the same order because the values() method returns the values in an unspecified order. Use a JSONArray or a List to store the data in the desired order before generating the JSONArray if you need to maintain the order of the items.

Reasons for conversion of JSONObject to JSONArray in java

We might need to convert a JSONObject in Java to a JSONArray for a variety of reasons. Common causes include the following.

Sending multiple objects: When we need to send multiple JSON objects to a server, we can pack them in a JSONArray and send them in a single request.
Data storage: It is simpler to save several JSON objects in a JSONArray format when we need to store them in a file or database.
Data JSON parsing: A single object or an array of objects may be present in the JSON data that we receive from a server. If we are expecting an array, we need to convert a single object to an array to process the data consistently.
Simplifying code: When working with JSON data in Java, it may be easier to work with a JSONArray instead of a JSONObject. For example, it is easier to iterate over the elements of a JSONArray than over the properties of a JSONObject.

Overall, converting a JSONObject to a JSONArray provides flexibility in handling JSON data in Java and can simplify the code when working with collections of JSON objects.

Methods for converting JSONObject to JSONArray in java

Using JSONArray constructor and put method
Using JSONArray constructor and Collections.singletonList method
Using JSONArray constructor, JSONObject.names, and JSONObject.get methods
Using JSONArray and JSONObject iterators

Approach 1. Convert jsonobject to jsonarray Using JSONArray constructor and put method

The JSONArray constructor is used to create a new empty JSONArray object in Java, while the put() method is used to add elements to the array. The put() method takes a single argument of any JSON-supported type and appends it to the end of the array.

Sample Code:

import org.json.*;

public class JsonObjectToJsonArrayExample {
  public static void main(String[] args) throws JSONException {
     // Create a JSONObject
     JSONObject jsonObject = new JSONObject();
     jsonObject.put("name", "John");
     jsonObject.put("age", 30);
     jsonObject.put("city", "New York");

     // Convert the JSONObject to a JSONArray
     JSONArray jsonArray = new JSONArray();
     jsonArray.put(jsonObject);

     // Print the JSONArray
     System.out.println(jsonArray);
  }
}

Output:

[{"name":"John","age":30,"city":"New York"}]

Code Explanation:

The preceding Java code example demonstrates how to convert a JSONObject into a JSONArray using the JSONObject and JSONArray classes from the org.json package:

Create a new JSONObject and add properties to it.
Create a new empty JSONArray.
Add the JSONObject to the JSONArray.
Print the JSONArray to the console.

Above code will result- the console should display the following JSON array:

This contains a single JSON object with three properties and is a valid JSON array.

Approach 2. Using JSONArray constructor and Collections.singletonList method

In Java, the Collections.singletonList method is used to build a new List object with a single given element, whereas the JSONArray function Object() { [native code] } is used to generate an empty JSONArray object.

Sample Code:

import org.json.*;

import java.util.Collections;

public class JsonObjectToJsonArrayExample {
  public static void main(String[] args) throws JSONException {
     // Create a JSONObject
     JSONObject jsonObject = new JSONObject();
     jsonObject.put("name", "John");
     jsonObject.put("age", 30);
     jsonObject.put("city", "New York");

     // Convert the JSONObject to a JSONArray
     JSONArray jsonArray = new JSONArray(Collections.singletonList(jsonObject));

     // Print the JSONArray
     System.out.println(jsonArray);
  }
}

Output:

[{"name":"John","age":30,"city":"New York"}]

Code Explanation:

The import statements import the necessary classes from the org.json and java.util packages.
Create a new JSONObject and add properties to it.
Use the Collections.singletonList() method to create a new List object containing the JSONObject.
Create a new JSONArray containing the single JSONObject element.
Print the JSONArray to the console.

However, note that the second example uses the Collections.singletonList() method to create the List object, which is then passed as an argument to the JSONArray constructor. This is a more concise way to create a JSONArray containing a single JSONObject element.

Approach 3: Conversion of jsonobject to jsonarray Using JSONArray constructor, JSONObject.names, and JSONObject.get methods –

The JSONArray constructor is used to create an empty JSONArray object in Java. The JSONObject.names() method is used to collect an array of property names from a JSONObject, whereas JSONObject.get() this method is used to collect the value of a property from a JSONObject name based.

Sample Code:

import org.json.*;

public class JsonObjectToJsonArrayExample {
  public static void main(String[] args) throws JSONException {
     // Create a JSONObject
     JSONObject jsonObject = new JSONObject();
     jsonObject.put("name", "John");
     jsonObject.put("age", 30);
     jsonObject.put("city", "New York");

     // Convert the JSONObject to a JSONArray
     JSONArray jsonArray = new JSONArray();
     JSONArray names = jsonObject.names();
     for (int i = 0; i < names.length(); i++) {
        jsonArray.put(jsonObject.get(names.getString(i)));
     }

     // Print the JSONArray
     System.out.println(jsonArray);
  }
}

Output:

["John",30,"New York"]

Code Explanation:

The import statement imports the necessary classes from the org.json package.
Create a new JSONObject and add properties to it.
Create a new empty JSONArray.
Retrieve an array of property names from the JSONObject using the names() method.
Iterate through the property names and add each property value to the JSONArray using the get() and put() methods.
Print the JSONArray to the console.

This is a more flexible way to convert a JSONObject to a JSONArray, as it allows for different ordering and filtering of the properties based on their names.

Best Approach

The JSONArray function Object() { [native code] }, JSONObject.names, and JSONObject.get methods are thought to be the ideal way to convert a JSONObject to a JSONArray in Java for a number of reasons.:

Easy and straightforward: These methods result in pretty straightforward and understandable code that converts a JSONObject to a JSONArray. It requires establishing a new JSONArray object, iterating through the JSONObject’s keys, and updating the JSONArray with the values.
Efficient: These methods are efficient because they do not require any additional libraries or dependencies. The JSONObject and JSONArray classes are built into Java, so there is no need to include any external libraries.
Customizable: The code can be easily customized to handle more complex JSON structures. A recursive function can be used to go through the JSON structure and add the items to the JSONArray, for instance, if the JSONObject contains nested objects or arrays.
Flexibility: These methods allow us to choose which properties to include in the resulting JSONArray. For example, we could choose to exclude certain properties or rename them if necessary.
Widely used: The JSONArray constructor, JSONObject.names, and JSONObject.get methods are widely used in Java and are well-documented, making it easy to find examples and resources online.

As a whole, these techniques are regarded as the best approach to convert a JSONObject to a JSONArray in Java since they are straightforward, effective, adaptable, customizable, and frequently used.

Sample Problem

Sample Problem 1

Scenario:Suppose we have a JSON object that contains information about a list of employees in a company. Each employee has a name, ID number, and department. We want to convert this JSON object to a JSON array that contains the same information but in a different format, where each element in the array represents an employee and contains the employee’s name, ID number, and department.

Solution:

We first create a JSONObject called employeeJsonObj that contains information about three employees in a company.
We then create a new JSONArray called employeeJsonArray to store the converted JSON data.
Using the JSONObject.getNames method, we retrieve an array of keys from the employeeJsonObj object.
We loop through each key in the array and retrieve the JSON object for the current key using the getJSONObject method.
We extract the name, ID, and department values from the current JSON object using the getString method.
We create a new JSONObject called employeeDetailsJsonObj for the current employee and add it to the employeeJsonArray using the put method.
Finally, we print the employeeJsonArray using the System.out.println method.

Solution Code:

import org.json.JSONArray;
import org.json.JSONObject;

public class JsonObjectToJsonArrayExample {
   public static void main(String[] args) {
       // Sample JSON object containing employee information
       JSONObject employeeJsonObj = new JSONObject();
       employeeJsonObj.put("employee1", new JSONObject()
               .put("name", "John")
               .put("id", "001")
               .put("department", "HR"));
       employeeJsonObj.put("employee2", new JSONObject()
               .put("name", "Jane")
               .put("id", "002")
               .put("department", "IT"));
       employeeJsonObj.put("employee3", new JSONObject()
               .put("name", "Bob")
               .put("id", "003")
               .put("department", "Finance"));

       // Retrieve the keys of the JSON object
       JSONArray employeeJsonArray = new JSONArray();
       for (String key : JSONObject.getNames(employeeJsonObj)) {
           // Retrieve the JSON object for the current key
           JSONObject currentEmployeeJsonObj = employeeJsonObj.getJSONObject(key);

           // Extract the name, ID, and department values from the JSON object
           String name = currentEmployeeJsonObj.getString("name");
           String id = currentEmployeeJsonObj.getString("id");
           String department = currentEmployeeJsonObj.getString("department");

           // Create a new JSON object for the current employee and add it to the JSON array
           JSONObject employeeDetailsJsonObj = new JSONObject();
           employeeDetailsJsonObj.put("name", name);
           employeeDetailsJsonObj.put("id", id);
           employeeDetailsJsonObj.put("department", department);
           employeeJsonArray.put(employeeDetailsJsonObj);
       }

       // Print the JSON array
       System.out.println(employeeJsonArray);
   }
}

Output:

[  {    "name": "John",    "id": "001",    "department": "HR"  },  
{    "name": "Jane",    "id": "002",    "department": "IT"  }, 
 {    "name": "Bob",    "id": "003",    "department": "Finance"  }]

Sample Problem 2

Scenario: A web service returns a JSON object containing information about a list of products. Each product has a name, description, price, and image URL. The client needs to display the products in a table format on the web page. To do this, the JSON object needs to be converted to a JSON array.

Solution:

The ProductConverter class has a static method convertToJSONArray that takes a JSON object containing product information and returns a JSON array of products.
Inside the convertToJSONArray method, a new JSON array is created using the JSONArray constructor.
The JSONObject.getNames method is used to get an array of product names from the input JSON object.
A for loop is used to iterate over the product names and retrieve the corresponding product JSON object using the JSONObject.getJSONObject method.
The retrieved product JSON object is added to the output JSON array using the JSONArray.put method.
The output JSON array is returned from the convertToJSONArray method.
In the main method, a sample JSON object containing two products is created using the JSONObject.put method.
The convertToJSONArray method is called with the sample JSON object as input.
The resulting JSON array is printed to the console using the JSONArray.toString method with an indentation level of 2.

Solution Code:

import org.json.JSONArray;
import org.json.JSONObject;

public class ProductConverter {
  public static JSONArray convertToJSONArray(JSONObject products) {
   JSONArray jsonArray = new JSONArray();
   String[] names = JSONObject.getNames(products);
   if (names != null) {
     for (String name : names) {
       JSONObject product = products.getJSONObject(name);
       jsonArray.put(product);
     }
   }
   return jsonArray;
 }

 public static void main(String[] args) {
   // Sample JSON object containing product information
   JSONObject products = new JSONObject();
   products.put("product1", new JSONObject()
       .put("name", "Product 1")
       .put("description", "This is product 1")
       .put("price", 10.99)
       .put("image_url", "https://example.com/product1.jpg"));
   products.put("product2", new JSONObject()
       .put("name", "Product 2")
       .put("description", "This is product 2")
       .put("price", 20.99)
       .put("image_url", "https://example.com/product2.jpg"));
      
   // Convert the JSON object to JSON array
   JSONArray jsonArray = convertToJSONArray(products);
  
   // Print the JSON array
   System.out.println(jsonArray.toString(2));
 }
}

Output:

[  {    "name": "Product 1",    "description": "This is product 1",    "price": 10.99,        "image_url": "https://example.com/product1.jpg"  }, 
{    "name": "Product 2",    "description": "This is product 2",    "price": 20.99,    "image_url": "https://example.com/product2.jpg"  }]

Sample Problem 3

Scenario: You have a JSON response from a web API that contains information about students in a class, but the response is a single JSON object instead of a JSON array. You need to convert this JSON object to a JSON array so that you can easily iterate over the students in your Java code.

Solution:

The JSON string is first parsed into a JSONObject using the JSONObject class.
An empty JSONArray is created using the JSONArray class.
The names() method of the JSONObject class is used to get an array of the names of the student objects within the “students” object.
A for loop is used to iterate over the names array and retrieve the corresponding student object using the getJSONObject() method of the JSONObject class.
Each student object is added to the new JSON array using the put() method of the JSONArray class.
The final JSON array is printed to the console using the toString() method of the JSONArray class.

Solution Code:

import org.json.*;

public class Main {
   public static void main(String[] args) {
       String jsonStr = "{\"students\":{\"1\":{\"name\":\"John Doe\",\"age\":21,\"grades\":[85,92,89]},\"2\":{\"name\":\"Jane Smith\",\"age\":19,\"grades\":[76,88,91]},\"3\":{\"name\":\"Bob Johnson\",\"age\":20,\"grades\":[90,87,93]}}}";

       JSONObject jsonObj = new JSONObject(jsonStr);
       JSONArray studentsArr = new JSONArray();

       // Get the names of the student objects
       JSONArray namesArr = jsonObj.getJSONObject("students").names();

       // Iterate over the student objects and add them to the new JSON array
       for (int i = 0; i < namesArr.length(); i++) {
           String studentId = namesArr.getString(i);
           JSONObject studentObj = jsonObj.getJSONObject("students").getJSONObject(studentId);
           studentsArr.put(studentObj);
       }

       // Print the new JSON array
       System.out.println(studentsArr.toString());
   }
}

Output:

[{"age":21,"grades":[85,92,89],"name":"John Doe"},
{"age":19,"grades":[76,88,91],"name":"Jane Smith"},
{"age":20,"grades":[90,87,93],"name":"Bob Johnson"}]

Conclusion

In conclusion, JSON is a popular data format for sharing data between various systems and programming languages. In Java, there are various methods available to convert a JSONObject to a JSONArray, including using the JSONArray constructor, put method, Collections.singletonList method, JSONObject names and JSONObject.get methods, and using JSONArray and JSONObject iterators.

The best method to convert a JSONObject to a JSONArray depends on the specific scenario and requirements. However, the JSONArray constructor, JSONObject.names, and JSONObject.get methods are generally considered to be the most efficient and effective method due to their simplicity and performance.

In real-life scenarios, JSON data is often used for web services, API communication, and data exchange between different applications. When JSON data needs to be processed as an array or when an API or library demands an array input, it can be helpful to convert a JSONObject to a JSONArray.For Java developers dealing with JSON data, being able to convert between multiple data formats, including JSONObject and JSONArray, is a crucial ability.

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

Author:

Navneet Yadav

I am an engineering student at SRMIST, majoring in computer science. I have developed proficiency in several programming languages, including C++, Java, Python, C, Linux, and front-end development. Follow: