How To Convert Jsonarray To Jsonobject in java

by
convert jsonarray to jsonobject in java

A JSONArray is an ordered collection of values represented as a square bracket[] -delimited list of values, where each value can be a primitive data type or another JSON object or JSONArray. It is commonly used to exchange data between different programming languages and systems in a JSON format.

A data structure called a JSONObject is used to display an unordered group of key-value pairs. It is a kind of data format used to transfer data between various systems and programming languages. Key-value pairs are separated from one another by commas and are enclosed in curly braces to form a JSONObject.

Creating a new JSONObject instance will loop over the JSONArray and then add each element as a key-value pair to the new JSONObject to convert a JSONArray to a JSONObject in Java.

Why we might require to convert JSONArray to JSONObject in java

You may need to convert a JSONArray to a JSONObject in Java in a variety of circumstances. These are a few typical explanations:

  1. While working with such types of JSON data, we might give data in the form of a JSONArray that you need to convert to a JSONObject in order to access particular values within the data.
  2. Data processing: You might need to transform or otherwise work with a lot of JSON data if it is contained in a JSONArray. Converting the JSONArray to a JSONObject can make it easier to process and manipulate the data.
  3. Data storage: You might need to convert a JSONArray into a JSONObject before storing it if you need to save JSON data in a database or another storage system.
  4. Data transmission: To make sure that JSON data is delivered correctly over a network, you might need to transform a JSONArray to a JSONObject.

In general, changing a JSONArray to a JSONObject might be helpful for a variety of applications where Java JSON data processing or manipulation is required.

Methods can be used for converting JSONArray to a JSONObject

  1. Iterate through the elements of the JSONArray and add them to a new JSONObject instance using the put method.
  2. Use a JSONObject constructor that accepts a Map object as an argument.
  3. Use a JSONObject constructor that accepts a JSON string as an argument.
  4. Use a JSONTokener to convert the JSONArray to a JSONObject.
  5. Use the org.json.JSONObject class’s putOpt method to convert the JSONArray to a JSONObject.

Approach 1: Iterate through the elements of the JSONArray and add them to a new JSONObject instance using the put method.

With this procedure, we loop through the JSONArray’s items and add each one to a fresh JSONObject object using the put method of the JSONObject class. The put method creates a new key-value pair for the JSONObject with a String as the key and any legitimate JSON object as the value (such as a String, int, boolean, or another JSONObject).

Example– Suppose we have the following JSONArray:

JSONArray jsonArray = new JSONArray(“[{\”name\”:\”John\”,\”age\”:30},{\”name\”:\”Jane\”,\”age\”:25}]”);

We want to convert this JSONArray to a JSONObject where the keys are the names and the values are the ages.

Sample Code:

JSONArray jsonArray = new JSONArray("[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]");

We want to convert this JSONArray to a JSONObject where the keys are the names and the values are the ages.

Sample Code:
// create a JSONArray object
JSONArray jsonArray = new JSONArray("[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]");

// create a new JSONObject instance
JSONObject jsonObject = new JSONObject();

// iterate through the elements of the JSONArray
for (int i = 0; i < jsonArray.length(); i++) {

   // get the i-th element of the JSONArray
   JSONObject tempObj = jsonArray.getJSONObject(i);

   // get the value of the "name" key
   String name = tempObj.getString("name");

   // get the value of the "age" key
   int age = tempObj.getInt("age");

   // add a new key-value pair to the JSONObject
   jsonObject.put(name, age);
}

Output:

Finally, the name and age values are added as a key-value pair to a JSONObject using the put method.

Code Explanation:

  1. Create a JSONArray object using a JSON string.
  2. Create a new JSONObject instance to hold the converted data.
  3. Iterate through the elements of the JSONArray using a for loop.
  4. For each element, get the JSONObject representation using the getJSONObject method.
  5. Get the values of the “name” and “age” keys using the getString and getInt methods, respectively.
  6. Add a new key-value pair to the JSONObject using the put method.

Approach 2. Use a JSONObject constructor that accepts a Map object as an argument:

The JSONObject method Object(), which accepts a Map object as an argument, is used in this function to generate a new instance of JSONObject. We create a Map object with names as keys and ages as values by repeatedly iterating through the JSONArray components and removing the values for the “name” and “age” fields. Finally, we instruct the JSONObject function Object() { [native code] } to create a new instance of JSONObject by accepting the Map object as an argument.

Example: Suppose we have the following JSONArray:

JSONArray jsonArray = new JSONArray("[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]");

We want to convert this JSONArray to a JSONObject where the keys are the names and the values are the ages.

Code:

// create a JSONArray object
JSONArray jsonArray = new JSONArray("[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]");

// create a new Map instance
Map<String, Integer> map = new HashMap<>();

// iterate through the elements of the JSONArray
for (int i = 0; i < jsonArray.length(); i++) {

   // get the i-th element of the JSONArray
   JSONObject tempObj = jsonArray.getJSONObject(i);

   // get the value of the "name" key
   String name = tempObj.getString("name");

   // get the value of the "age" key
   int age = tempObj.getInt("age");

   // add a new key-value pair to the Map
   map.put(name, age);
}

// create a new JSONObject using the Map constructor
JSONObject jsonObject = new JSONObject(map);

System.out.println(jsonObject.toString());

Output:

{"John":30,"Jane":25}

Explanation:

  1. Create a new JSONObject instance.
  2. Create a new Map instance using the HashMap class.
  3. Iterate through the elements of the JSONArray using a for loop.
  4. For each element, get the JSONObject representation using the getJSONObject method.
  5. Get the values of the “name” and “age” keys using the getString and getInt methods, respectively.
  6. Add a new key-value pair to the Map using the put method.
  7. Create a new JSONObject using the Map constructor.

Note: We can also skip creating an empty JSONObject instance and directly create the Map and JSONObject instances in one step by using a single for loop and the put method of the Map object.

Approach 3. Use a JSONObject constructor that accepts a JSON string as an argument.

In order to build a new JSONObject instance in this method, we utilise a JSONObject function Object() { [native code] } that takes a JSON string as an input. First, we use the function toString() { [native code] } method to turn the JSONArray into a JSON string. The JSONObject function Object() { [native code] } is then called with this string as an input to generate a new JSONObject instance.

Example: Suppose we have the following JSONArray:

JSONArray jsonArray = new JSONArray("[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]");

Code:

// create a JSONArray object
JSONArray jsonArray = new JSONArray("[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]");

// create a new JSONObject instance using the JSON string
JSONObject jsonObject = new JSONObject(jsonArray.toString());

Output:

{"name":"Jane","age":25}

Explanation:

  1. Convert the JSONArray to a JSON string using the toString method.
  2. Pass the JSON string as an argument to the JSONObject constructor to create a new JSONObject instance.

Note: This method assumes that the JSON string representing the JSONArray is well-formed and valid. If the JSON string is malformed or invalid, a JSONException will be thrown.

Approach 4. Use a JSONTokener to convert the JSONArray to a JSONObject

To convert a JSONArray to a JSONObject, we can use the JSONTokener class. This class provides a way to convert a JSON string or a Reader containing a JSON object or array into a JSONObject or JSONArray respectively.

Code:

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

public class Example {
 public static void main(String[] args) {
   String jsonArrayString = "[{\"name\":\"John\",\"age\":30},{\"name\":\"Jane\",\"age\":25}]";
   JSONArray jsonArray = new JSONArray(jsonArrayString);
   JSONTokener tokener = new JSONTokener(jsonArray.toString());
   JSONObject jsonObject = new JSONObject(tokener);
   System.out.println(jsonObject);
 }
}

Output:

{"name":"John","age":30},{"name":"Jane","age":25}

Explanation:

  1. We start by defining a string representation of a JSONArray called jsonArrayString. This string contains two JSON objects, each with a name and age field.
  2. We create a JSONArray object called jsonArray using the JSONArray constructor and passing the jsonArrayString as an argument.
  3. We create a JSONTokener object called tokener using the JSONTokener constructor and passing the string representation of the jsonArray object obtained using the toString() method.
  4. We create a new JSONObject called jsonObject using the JSONObject constructor and passing the tokener object as an argument. This will convert the jsonArray object to a JSONObject.
  5. We print the jsonObject to the console using the println() method of System.out. This will output the converted JSONObject.

Best Approach for converting JSONArray to a JSONObject

It is difficult to say which technique is unquestionably the “best” method for converting a JSONArray to a JSONObject because the ideal method may vary depending on the particular demands and specifications of the project or application.

However, the put() method can be a good option for several reasons:

  1. It is included in the org.json library’s JSONObject class, which is a widely used library for working with JSON data in Java. This implies that in order to utilise this method, your project does not require the addition of any external libraries or dependencies.
  2. Given that you may add a new key-value pair to a JSONObject with just one line of code, the put() method is straightforward and simple to grasp.
  3. The put() method allows you to quickly and readable generate a new JSONObject from a JSONArray by iterating through the JSONArray and adding each object to the new JSONObject with a distinct key.
  4. This method assumes that each object in the JSONArray has a unique key, which may be a useful constraint for certain use cases.

It should be understood that this approach does have some drawbacks. For instance, only the final object with a certain key will be included in the final JSONObject if the JSONArray contains objects with non-unique keys. Moreover, iterating through a big JSONArray can take a while, so this method might not be the best option if efficiency is important.

Sample Problems

Problem 1

Problem: Suppose we have a JSONArray representing a list of orders from an online store. Each order has the following properties: orderId, customerId, totalPrice, orderDate, and items. The items property is a nested JSONArray that contains a list of items in the order, each of which has a itemId, itemName, itemPrice, and itemQuantity. We want to convert this JSONArray to a JSONObject that represents the total revenue of the store for each day.

Solution

We can solve this problem by iterating through the elements of the JSONArray and extracting the relevant information for each order. For each order, we can use the orderDate property as a key in a new JSONObject, and we can add the totalPrice of the order to the value for that key. This will give us a JSONObject that maps each order date to the total revenue for that day.

Code:

// create a JSONArray object representing a list of orders
JSONArray ordersArray = new JSONArray("[{\"orderId\":1,\"customerId\":1,\"totalPrice\":100,\"orderDate\":\"2022-03-25\",\"items\":[{\"itemId\":1,\"itemName\":\"Item 1\",\"itemPrice\":50,\"itemQuantity\":2},{\"itemId\":2,\"itemName\":\"Item 2\",\"itemPrice\":25,\"itemQuantity\":2}]},{\"orderId\":2,\"customerId\":2,\"totalPrice\":200,\"orderDate\":\"2022-03-25\",\"items\":[{\"itemId\":3,\"itemName\":\"Item 3\",\"itemPrice\":75,\"itemQuantity\":2},{\"itemId\":4,\"itemName\":\"Item 4\",\"itemPrice\":25,\"itemQuantity\":4}]},{\"orderId\":3,\"customerId\":1,\"totalPrice\":150,\"orderDate\":\"2022-03-26\",\"items\":[{\"itemId\":5,\"itemName\":\"Item 5\",\"itemPrice\":50,\"itemQuantity\":3},{\"itemId\":6,\"itemName\":\"Item 6\",\"itemPrice\":25,\"itemQuantity\":3}]}]");

// create a new JSONObject to store the daily revenue
JSONObject dailyRevenue = new JSONObject();

// iterate through the orders and add the total price to the daily revenue for the order date
for (int i = 0; i < ordersArray.length(); i++) {
   JSONObject order = ordersArray.getJSONObject(i);
   String orderDate = order.getString("orderDate");
   int totalPrice = order.getInt("totalPrice");

   if (dailyRevenue.has(orderDate)) { // if the order date already exists in the daily revenue object
       int revenue = dailyRevenue.getInt(orderDate); // get the current revenue for that date
       dailyRevenue.put(orderDate, revenue + totalPrice); // add the new revenue to the existing revenue
   } else { // if the order date does not exist in the daily revenue object
       dailyRevenue.put(orderDate, totalPrice); // add the new order revenue to the daily revenue object
   }
}

// print the daily revenue object as a JSON string
System.out.println(dailyRevenue.toString());

Output:

{"2022-03-25":300,"2022-03-26":150}

Explanation:

  1. Create a new JSONObject to store the daily revenue
  2. Iterate through the orders in the JSONArray
  3. Extract the orderDate and totalPrice properties from each order using the getString and getInt methods of the JSONObject class, respectively
  4. Check if the daily revenue JSONObject already has an entry for the order date
  5. If it does, get the current revenue value using the getInt method and add the totalPrice to it using the put method
  6. If it doesn’t, add a new entry to the JSONObject with the order date as the key and the totalPrice as the value using the put method
  7. Print the daily revenue JSONObject

Problem 2

Suppose we have a JSONArray representing a list of employees in a company. Each employee has the following properties: employeeId, name, department, salary, and hireDate. We want to convert this JSONArray to a JSONObject that groups the employees by department and calculates the average salary for each department.

Solution:By repeatedly iterating through the JSONArray’s elements and removing the pertinent data for each employee, we can find a solution to this issue. We may create a new JSONObject for each employee using the department field as a key, and we can add the employee’s salary to a running total for that department. The amount of personnel employed by each department can also be monitored. By dividing the total salary by the number of employees in each department after going through each employee one by one, we can determine the average salary for each department. This will provide us with a JSONObject that associates the average wage for each department with that department.

Code:

JSONArray employeesArray = new JSONArray("[{\"employeeId\":1,\"name\":\"John\",\"department\":\"Sales\",\"salary\":50000,\"hireDate\":\"2020-01-01\"},{\"employeeId\":2,\"name\":\"Jane\",\"department\":\"Marketing\",\"salary\":60000,\"hireDate\":\"2019-01-01\"},{\"employeeId\":3,\"name\":\"Bob\",\"department\":\"Sales\",\"salary\":55000,\"hireDate\":\"2018-01-01\"},{\"employeeId\":4,\"name\":\"Alice\",\"department\":\"Marketing\",\"salary\":65000,\"hireDate\":\"2021-01-01\"},{\"employeeId\":5,\"name\":\"Tom\",\"department\":\"Sales\",\"salary\":60000,\"hireDate\":\"2017-01-01\"}]");

// create a new JSONObject to store the departmental average salaries
JSONObject departmentSalaries = new JSONObject();

// iterate through the employees and add the salaries to the running total for each department
// and keep track of the number of employees in each department
for (int i = 0; i < employeesArray.length(); i++) {
   JSONObject employee = employeesArray.getJSONObject(i);
   String department = employee.getString("department");
   int salary = employee.getInt("salary");

   if (departmentSalaries.has(department)) {
       JSONObject departmentData = departmentSalaries.getJSONObject(department);
       int totalSalary = departmentData.getInt("totalSalary");
       int employeeCount = departmentData.getInt("employeeCount");
       departmentData.put("totalSalary", totalSalary + salary);
       departmentData.put("employeeCount", employeeCount + 1);
   } else {
       JSONObject departmentData = new JSONObject();
       departmentData.put("totalSalary", salary);
       departmentData.put("employeeCount", 1);
       departmentSalaries.put(department, departmentData);
   }
}

// calculate the average salary for each department
for (String department : departmentSalaries.keySet()) {
   JSONObject departmentData = departmentSalaries.getJSONObject(department);
   int totalSalary = departmentData.getInt("totalSalary");
   int employeeCount = departmentData.getInt("employeeCount");
   double averageSalary = (double) totalSalary / employeeCount;
   departmentData.put("averageSalary", averageSalary);
}

System.out.println(departmentSalaries.toString());

Output:

{
   "Sales": {
     "totalSalary": 165000,
     "employeeCount": 3,
     "averageSalary": 55000.0
   },
   "Marketing": {
     "totalSalary": 125000,
     "employeeCount": 2,
     "averageSalary": 62500.0
   }
 }

 Explanation:

  1. Extracts employee details from a JSON array
  2. Calculates the average salary for each department
  3. Uses a JSONObject to store department-wise total salaries and employee counts
  4. Checks if an entry exists for the employee’s department in the JSONObject
  5. Adds the employee’s salary and count to existing values, otherwise, creates a new JSONObject
  6. Calculates the average salary for each department and stores it in the JSONObject
  7. Prints the department-wise total salaries, employee counts, and average salaries to the console.

Problem 3

Problem: Suppose we have a JSONArray representing a list of products in an e-commerce website. Each product has the following properties: productId, name, category, price, and rating. We want to convert this JSONArray to a JSONObject that groups the products by category and calculates the average price and average rating for each category.

Solution: We can solve this problem by iterating through the elements of the JSONArray and extracting the relevant information for each product. For each product, we can use the category property as a key in a new JSONObject, and we can add the price and rating of the product to running totals for that category. We can also keep track of the number of products in each category. After iterating through all the products, we can calculate the average price and average rating for each category by dividing the total price and rating by the number of products in that category. This will give us a JSONObject th

Code:

JSONArray productsArray = new JSONArray("[{\"productId\":1,\"name\":\"iPhone 13\",\"category\":\"Electronics\",\"price\":999,\"rating\":4.5},{\"productId\":2,\"name\":\"MacBook Pro\",\"category\":\"Electronics\",\"price\":1299,\"rating\":4.8},{\"productId\":3,\"name\":\"Lululemon Leggings\",\"category\":\"Clothing\",\"price\":98,\"rating\":4.3},{\"productId\":4,\"name\":\"Nike Air Zoom\",\"category\":\"Shoes\",\"price\":129,\"rating\":4.6},{\"productId\":5,\"name\":\"Kiehl's Ultra Facial Cream\",\"category\":\"Beauty\",\"price\":32,\"rating\":4.2}]");

// create a new JSONObject to store the category-wise average price and rating
JSONObject categoryData = new JSONObject();

// iterate through the products and add the prices and ratings to the running totals for each category
// and keep track of the number of products in each category
for (int i = 0; i < productsArray.length(); i++) {
   JSONObject product = productsArray.getJSONObject(i);
   String category = product.getString("category");
   double price = product.getDouble("price");
   double rating = product.getDouble("rating");

   if (categoryData.has(category)) {
       JSONObject categoryInfo = categoryData.getJSONObject(category);
       double totalPrice = categoryInfo.getDouble("totalPrice");
       double totalRating = categoryInfo.getDouble("totalRating");
       int productCount = categoryInfo.getInt("productCount");
       categoryInfo.put("totalPrice", totalPrice + price);
       categoryInfo.put("totalRating", totalRating + rating);
       categoryInfo.put("productCount", productCount + 1);
   } else {
       JSONObject categoryInfo = new JSONObject();
       categoryInfo.put("totalPrice", price);
       categoryInfo.put("totalRating", rating);
       categoryInfo.put("productCount", 1);
       categoryData.put(category, categoryInfo);
   }
}

// calculate the average price and rating for each category
for (String category : categoryData.keySet()) {
   JSONObject categoryInfo = categoryData.getJSONObject(category);
   double totalPrice = categoryInfo.getDouble("totalPrice");
   double totalRating = categoryInfo.getDouble("totalRating");
   int productCount = categoryInfo.getInt("productCount");
   double averagePrice = totalPrice / productCount;
   double averageRating = totalRating / productCount;
   categoryInfo.put("averagePrice", averagePrice);
   categoryInfo.put("averageRating", averageRating);
}

System.out.println(categoryData.toString());

Output:

{
   "Electronics": {
     "totalPrice": 2298.0,
     "totalRating": 9.3,
     "productCount": 2,
     "averagePrice": 1149.0,
     "averageRating": 4.65
   },
   "Clothing": {
     "totalPrice": 98.0,
     "totalRating": 4.3,
     "productCount": 1,
     "averagePrice": 98.0,
     "averageRating": 4.3
   },
   "Shoes": {
     "totalPrice": 129.0,
     "totalRating": 4.6,
     "productCount": 1,
     "averagePrice": 129.0,
     "averageRating": 4.6
   },
   "Beauty": {
     "totalPrice": 32.0,
     "totalRating": 4.2,

Explanation:

  1. The code defines a JSONArray named productsArray which contains a list of products as JSON objects, each with properties such as productId, name, category, price, and rating.
  2. A new JSONObject named categoryData is created to store the category-wise average price and rating.
  3. The code iterates through the productsArray and adds the prices and ratings to the running totals for each category, while keeping track of the number of products in each category.
  4. If a category is already present in categoryData, its totalPrice, totalRating, and productCount values are updated accordingly. If not, a new JSONObject is created to store this information for the category.
  5. After iterating through all the products, the code calculates the average price and rating for each category and stores these values in the corresponding JSONObject in categoryData.
  6. Finally, the categoryData JSONObject is printed to the console in string format.

Overall, the code calculates the category-wise average price and rating for a list of products using JSON objects and arrays in Java.

Conclusion

Finally, there are a variety of techniques to change a JSONArray into a JSONObject in Java. Some of the techniques include utilising a JSONObject function Object() { [native code] } that accepts a Map object or a JSON string as a parameter, iterating through the JSONArray’s elements and adding them to a new JSONObject instance using the put method, and parsing the JSONArray into a JSONObject using a JSONTokener.

The developer’s preference and the particular use case determine the method to be used. For instance, the put method approach is straightforward and simple to comprehend, but it might not be appropriate for huge datasets. The JSONTokener technique, however, may be more difficult to develop and may be better suited for huge datasets due to its memory efficiency.

In general, it’s important to choose a method that is efficient, easy to maintain and meets the requirements of the application.

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:
Copyright © 2023. All rights reserved.