How To Convert Arraylist To Jsonarray In Java

by
arraylist to jsonarray in java

While an ArrayList is a dynamic data structure in Java that enables you to store a collection of components that can expand or shrink in size as needed, JSONArray is a class that provides an ordered series of items in JSON format.

In Java, arrays and arraylists can perform operations including adding, removing, finding, sorting, and replacing elements in addition to storing a lot of identical-type variables. JSON is a text-based data interchange standard that can be seen as the vector-like object JsonArray.

Why conversion of arraylist to jsonarray in java is important

Here are some reasons:

  1. The lightweight JSON data interchange format is simple to read and write by both people and machines.
  2. Working with web APIs and services that use JSON as their data format is made simpler by converting data to a JSON array.
  3. Converting ArrayList to JSONArray facilitates easy serialization and deserialization of data in JSON format for storage and transfer between systems.
  4. Converting ArrayList to JSONArray in Java allows for the creation of complex data structures that can be easily represented and manipulated as JSON.

Methods for converting arraylist to jsonarray

Here are three common methods:

Method 1: Using JSONArray constructor and addAll() method

Method 2: Using a for loop and put() method

Method 3: Using Java Streams and JSONArray()

Method 4: Using Google’s Gson library

Method 5: Using Jackson library

Approach 1 Using JSONArray constructor and addAll() method

The main function of the addAll() method in Java is to add elements into a Java collection. There are two addAll() methods in Java:

  • The static method in the Collections class
  • The instance method in the Collection interface.

Code:

import com.fasterxml.jackson.databind.ObjectMapper;
import org.json.JSONArray;
import java.util.ArrayList;

public class ArrayListToJSONArrayExample {
   public static void main(String[] args) throws Exception {
       ArrayList<String> list = new ArrayList<>();
       list.add("apple");
       list.add("banana");
       list.add("orange");

       ObjectMapper mapper = new ObjectMapper();
       JSONArray jsonArray = new JSONArray(mapper.writeValueAsString(list));
       System.out.println(jsonArray.toString());
   }
}
// import the necessary classes
import org.json.JSONArray;
import java.util.ArrayList;


// define the class name
public class ArrayListToJSONArrayExample {
  // define the main method
  public static void main(String[] args) {
      // create a new ArrayList of type String and add some elements
      ArrayList<String> list = new ArrayList<>();
      list.add("apple");
      list.add("banana");
      list.add("orange");


      // create a new JSONArray object and pass the ArrayList as a parameter
      JSONArray jsonArray = new JSONArray(list);


      // print the JSONArray as a string
      System.out.println(jsonArray.toString());
  }
}

Output:

["apple","banana","orange"]

Explanation:

  • The main method of the program creates an ArrayList of Strings named “list” and adds three elements to it using the “add” method.
  • The code then will convert the ArrayList to a JSONArray using the JSONArray constructor by taking an ArrayList as an argument.
  • The resulting JSONArray is then printed to the console as a String using the “toString” method.

Approach 2 Using a for loop and put() method

As mentioned, Java for loop helps execute a set of code repeatedly, and it is recommended when the number of iterations is fixed.

Code:

// import the necessary classes
import org.json.JSONArray;
import java.util.ArrayList;


// define the class name
public class ArrayListToJSONArrayExample {
  // define the main method
  public static void main(String[] args) {
      // create a new ArrayList of type String and add some elements
      ArrayList<String> list = new ArrayList<>();
      list.add("apple");
      list.add("banana");
      list.add("orange");


      // create a new empty JSONArray object
      JSONArray jsonArray = new JSONArray();


      // iterate through each element in the ArrayList and add it to the JSONArray
      for (String item : list) {
          jsonArray.put(item);
      }


      // print the JSONArray as a string
      System.out.println(jsonArray.toString());
  }
}

Output:

["apple","banana","orange"]

Explanation:

  • The ‘main’ method is defined, which is the entry point of the program.
  • A new ArrayList of type String is created and named ‘list’.
  • The ‘add’ method is used to add three elements to the ArrayList: “apple”, “banana”, and “orange”.
  • A new JSONArray object is created and named ‘jsonArray’.
  • A for-each loop is used to iterate over the elements of the ‘list ‘ArrayList.
  • In each iteration, the current element of the ‘list’ ArrayList is added to the ‘jsonArray’ using the ‘put’ method of the JSONArray class.
  • Finally, the ‘toString’ method is used to convert the ‘jsonArray’ to a string, and it is printed to the console using the ‘println’ method.

Approach 3 Using Java Streams and JSONArray()

A stream is a pipeline of computational processes that transports elements from a source, such as a data structure, an array, a generating function, or an I/O channel.

Code:

import org.json.JSONArray;
import java.util.ArrayList;


public class ArrayListToJSONArrayExample {
  public static void main(String[] args) {
      // create a new ArrayList of type String and add some elements
      ArrayList<String> list = new ArrayList<>();
      list.add("apple");
      list.add("banana");
      list.add("orange");


      // create a new JSONArray object using the toArray() method of the Stream interface
      // and passing the ArrayList as a parameter
      JSONArray jsonArray = new JSONArray(list.stream().toArray());


      // print the JSONArray as a string
      System.out.println(jsonArray.toString());
  }
}

Output:

["apple","banana","orange"]

Explanation:

  • The ‘main’ method is defined, which is the entry point of the program.
  • A new ArrayList of type String is created and named ‘list’.
  • The ‘add’ method is used to add three elements to the ArrayList: “apple”, “banana”, and “orange”.
  • A new JSONArray object is created using the ‘toArray()’ method of the ‘Stream’ interface.
  • The ‘toArray()’ method takes the ‘list’ ArrayList as a parameter and converts it to an array.
  • The resulting array is then used to create the ‘jsonArray’ object.
  • Finally, the ‘toString’ method is used to convert the ‘jsonArray’ to a string, and it is printed to the console using the ‘println’ method.

Approach 4 Using Google’s Gson library

Google Gson is a simple Java-based library to serialize Java objects to JSON and vice versa. It is an open-source library developed by Google.

Code:

import com.google.gson.Gson;
import org.json.JSONArray;
import java.util.ArrayList;


public class ArrayListToJSONArrayExample {
  public static void main(String[] args) {
      // create a new ArrayList of type String and add some elements
      ArrayList<String> list = new ArrayList<>();
      list.add("apple");
      list.add("banana");
      list.add("orange");


      // create a new Gson object
      Gson gson = new Gson();


      // use the toJson() method of the Gson class to convert the ArrayList to a JSON string
      // and pass the resulting string as a parameter to the JSONArray constructor
      JSONArray jsonArray = new JSONArray(gson.toJson(list));


      // print the JSONArray as a string
      System.out.println(jsonArray.toString());
  }
}

Output:

["apple","banana","orange"]

Explanation:

  • The ‘main’ method is defined, which is the entry point of the program.
  • A new ArrayList of type String is created and named ‘list’.
  • The ‘add’ method is used to add three elements to the ArrayList: “apple”, “banana”, and “orange”.
  • A new Gson object is created.
  • The ‘toJson’ method of the Gson object is used to convert the ‘list’ ArrayList to a JSON string.
  • The resulting JSON string is then used to create the ‘jsonArray’ object.
  • The ‘jsonArray’ is now finally converted to a string using the ‘toString’ given method, and a console printout as output is generated using the ‘println’ method.

Approach 5 Using Jackson library

Jackson is a very popular and efficient java based library to serialize or map java objects to JSON and vice versa. This tutorial will teach you basic and advanced Jackson library API features and their usage in a simple and intuitive way.

Code:

import com.fasterxml.jackson.databind.ObjectMapper;
import org.json.JSONArray;
import java.util.ArrayList;


public class ArrayListToJSONArrayExample {
  public static void main(String[] args) throws Exception {
      // create a new ArrayList of type String and add some elements
      ArrayList<String> list = new ArrayList<>();
      list.add("apple");
      list.add("banana");
      list.add("orange");


      // create a new ObjectMapper object
      ObjectMapper mapper = new ObjectMapper();


      // use the writeValueAsString() method of the ObjectMapper class to convert the ArrayList to a JSON string
      // and pass the resulting string as a parameter to the JSONArray constructor
      JSONArray jsonArray = new JSONArray(mapper.writeValueAsString(list));


      // print the JSONArray as a string
      System.out.println(jsonArray.toString());
  }
}

Output:

["apple","banana","orange"]

Explanation:

  • The ‘main’ method is defined, which is the entry point of the program. It also throws an exception if any occurs.
  • A new ArrayList of type String is created and named ‘list’.
  • The ‘add’ method is used to add three elements to the ArrayList: “apple”, “banana”, and “orange”.
  • A new ‘ObjectMapper’ object is created.
  • The ‘writeValueAsString’ method of the ‘ObjectMapper’ object is used to convert the ‘list’ ArrayList to a JSON string.
  • The resulting JSON string is then used to create the ‘jsonArray’ object.
  • Finally, the ‘toString’ method is used to convert the ‘jsonArray’ to a string, and it is printed to the console using the ‘println’ method.

Best Approach Using Google’s Gson library

Following are the some Reasons:

  • Gson is a popular and widely-used library for converting Java objects to JSON and vice versa.
  • It provides a simple and efficient API for handling JSON data, with support for customization and configuration.
  • Gson provides a ‘toJson’ method that can be used to convert a Java object to a JSON string, and a ‘fromJson’ method that can be used for conversion.
  • Gson is a flexible tool for handling JSON data in Java since it supports handling complicated data structures like nested arrays and objects.

Sample Problem For Converting arraylist to jsonarray in Java

Sample problem 1

There is an ArrayList of books in a library. This list needs to be transformed into a JSON array format so that the library may store and share it with other libraries. Write a Java program that takes user-defined input for a list of books and converts it to a JSON array using the JSONArray constructor and the addAll() method.

Solution:

  • The user is prompted to input the total number of books before the programme requests information on the title, author, and release year of each book.
  • It stores the details of each book in a JSONObject and adds the JSONObject to an ArrayList.
  • Once all the books have been added, the program converts the ArrayList to a JSONArray.
  • The program then prints the JSONArray to the console with an indentation of 2 spaces for improved readability.
  • The program uses the ‘org.json’ library for handling JSON data in Java.

Code:

import org.json.JSONArray;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.Scanner;


// Define a class to convert an ArrayList of books to a JSONArray
public class ArrayListToJSONArrayExample {
 
  public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);
     
      // Get the number of books from the user
      System.out.print("Enter the number of books: ");
      int numBooks = scanner.nextInt();


      // Create an empty ArrayList to store the books
      ArrayList<JSONObject> books = new ArrayList<>();


      // Get details of each book from the user and add to the ArrayList
      for (int i = 1; i <= numBooks; i++) {
          System.out.print("Enter the title of book " + i + ": ");
          String title = scanner.next();


          System.out.print("Enter the author of book " + i + ": ");
          String author = scanner.next();


          System.out.print("Enter the year of publication of book " + i + ": ");
          int year = scanner.nextInt();


          // Create a JSONObject to store the details of the book
          JSONObject book = new JSONObject();
          book.put("title", title);
          book.put("author", author);
          book.put("year", year);


          // Add the book to the ArrayList
          books.add(book);
      }


      // Convert the ArrayList to a JSONArray
      JSONArray jsonArray = new JSONArray();
      jsonArray.addAll(books);


      // Print the JSONArray
      System.out.println("The JSON array of books is:\n" + jsonArray.toString(2));
  }
}

Output:

Enter the number of books: 2
Enter the title of book 1: The Great Gatsby
Enter the author of book 1: F. Scott Fitzgerald
Enter the year of publication of book 1: 1925
Enter the title of book 2: To Kill a Mockingbird
Enter the author of book 2: Harper Lee
Enter the year of publication of book 2: 1960

The JSON array of books is:
[
  {
    "title": "The Great Gatsby",
    "author": "F. Scott Fitzgerald",
    "year": 1925
  },
  {
    "title": "To Kill a Mockingbird",
    "author": "Harper Lee",
    "year": 1960
  }
]

Sample problem 2

Suppose you and your team are working on a project to create a messaging system for a respected company. You must create a Java programme for this project that receives a list of user messages, transforms the list into a JSON array, and then delivers the JSON data to the server.

Solution:

  • The ‘MessageConverter’ class contains a ‘main’ method, which is the entry point for the program.
  • The ‘Scanner’ class is used to read user input from the command line.
  • The program prompts the user to enter the number of messages they want to convert to JSON.
  • The program creates an ‘ArrayList’ to hold the user’s messages.
  • The program loops through the number of messages the user wants to enter and prompts the user to enter each message.
  • Each message is added to the ‘ArrayList’.
  • The program creates a new ‘JSONArray’ to hold the JSON objects that will be created from the user’s messages.
  • The program loops through the ‘ArrayList’ of messages and creates a new ‘JSONObject’ for each message.
  • Each ‘JSONObject’ contains a single key-value pair, where the key is “message” and the value is the message itself.
  • Each ‘JSONObject’ is added to the ‘JSONArray’.
  • The program prints out the JSON array of messages using the ‘toString’ method, with an indentation of 2 spaces for readability.

Code:

import org.json.JSONArray;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.Scanner;


public class MessageConverter {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);


       // Prompt user to enter the number of messages they want to convert to JSON
       System.out.print("Enter the number of messages: ");
       int numMessages = scanner.nextInt();


       // Create an ArrayList to hold the user's messages
       ArrayList<String> messages = new ArrayList<>();


       // Loop through the number of messages the user wants to enter
       for (int i = 1; i <= numMessages; i++) {
           // Prompt user to enter the message
           System.out.print("Enter message " + i + ": ");
           String message = scanner.next();


           // Add the message to the ArrayList
           messages.add(message);
       }


       // Create a new JSON array
       JSONArray jsonArray = new JSONArray();


       // Loop through the ArrayList of messages
       for (String message : messages) {
           // Create a new JSON object for each message
           JSONObject jsonObject = new JSONObject();
           // Add the message to the JSON object
           jsonObject.put("message", message);
           // Add the JSON object to the JSON array
           jsonArray.put(jsonObject);
       }


       // Print out the JSON array of messages
       System.out.println("The JSON array of messages is:\n" + jsonArray.toString(2));
   }
}

Output:

Enter the number of messages: 3
Enter message 1: Hello
Enter message 2: How are you?
Enter message 3: I am fine
The JSON array of messages is:
[
  {
    "message": "Hello"
  },
  {
    "message": "How are you?"
  },
  {
    "message": "I am fine"
  }
]

Sample problem 3

Suppose you and your team are working on a project to develop an online store for a client. You must create a Java programme for this project that receives a client-supplied list of products, transforms the list into a JSON array using Java Streams and the JSONArray class, and then delivers the JSON data to the server.

To accomplish this task, you decide to use Java Streams and the JSONArray class from the org.json package in Java.

Solution:

This Java code prompts the user to input details of a certain number of products, creates a list of Product objects, and then converts it to a JSONArray of JSONObjects. Here is a summary of the code’s functionality in points:

  • It defines a Product class that contains a name, price, and description, as well as a method toJson() that creates a JSONObject representation of the product.
  • It defines a ProductConverter class that prompts the user to input a certain number of products and then creates an ArrayList of Product objects based on the input.
  • It calls the toJson() function on each Product object in the ArrayList using the stream() and map() methods, and then uses the collect() method to produce a List of the resulting JSONObjects.
  • It prints the resulting JSONArray to the console in a readable format.

Code:

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


import java.util.ArrayList;
import java.util.Scanner;
import java.util.stream.Collectors;


public class ProductConverter {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);


       // Prompt user to enter the number of products they want to convert to JSON
       System.out.print("Enter the number of products: ");
       int numProducts = scanner.nextInt();


       // Create an ArrayList to hold the user's products
       ArrayList<Product> products = new ArrayList<>();


       // Loop through the number of products the user wants to enter
       for (int i = 1; i <= numProducts; i++) {
           // Prompt user to enter the product name
           System.out.print("Enter product " + i + " name: ");
           String name = scanner.next();


           // Prompt user to enter the product price
           System.out.print("Enter product " + i + " price: ");
           double price = scanner.nextDouble();


           // Prompt user to enter the product description
           System.out.print("Enter product " + i + " description: ");
           String description = scanner.next();


           // Create a new Product object and add it to the ArrayList
           products.add(new Product(name, price, description));
       }


       // Convert the ArrayList of Products to a JSON array of JSONObjects
       JSONArray jsonArray = new JSONArray(products.stream()
               .map(Product::toJson) // Convert each Product object to a JSONObject using the "toJson" method
               .collect(Collectors.toList()));


       // Print out the JSON array of products
       System.out.println("The JSON array of products is:\n" + jsonArray.toString(2));
   }
}


// Product class to hold information about a single product
class Product {
   private String name;
   private double price;
   private String description;


   // Constructor to create a new Product object
   public Product(String name, double price, String description) {
       this.name = name;
       this.price = price;
       this.description = description;
   }


   // Method to convert the Product object to a JSONObject
   public JSONObject toJson() {
       JSONObject jsonObject = new JSONObject();
       jsonObject.put("name", this.name);
       jsonObject.put("price", this.price);
       jsonObject.put("description", this.description);
       return jsonObject;
   }
}

Output:

Enter the number of products: 2
Enter product 1 name: Laptop
Enter product 1 price: 50000
Enter product 1 description: Dell XPS
Enter product 2 name: Phone
Enter product 2 price: 15000
Enter product 2 description: OnePlus 8T


The JSON array of products is:
[
  {
    "price": 50000,
    "name": "Laptop",
    "description": "Dell XPS"
  },
  {
    "price": 15000,
    "name": "Phone",
    "description": "OnePlus 8T"
  }
]

Sample problem 4

Suppose you are assigned the task of building a web application for a newly registered online store. To display a list of products on a website, you must have to translate an ArrayList of products into a JSON format for order processing.

Solution using Google’s Gson library:

First, you need to add the Gson library to your project. You can do this by adding the following dependency to your pom.xml file if you’re using Maven:

Xml

            <dependency>

    <groupId>com.google.code.gson</groupId>

    <artifactId>gson</artifactId>

    <version>2.8.8</version>

</dependency>

or by adding the jar file to the classpath of your project after getting it from the official website.

Your ArrayList can be converted to a JSON format using the Gson class once the Gson library has been added to your project.

Here are the steps involved:

  1. The user is prompted to enter the desired number of products before the code uses a scanner to read each product’s specific information.
  2. The details of each product are stored as String objects in an ArrayList.
  3. The Gson class is used to create a JSON string representation of the ArrayList of String objects.
  4. The resulting JSON string is printed to the console.

There is no need for a custom class here as the input data is simple strings, which are directly added to the ArrayList and then converted to JSON using Gson.

Here’s the code:

import com.google.gson.Gson;
import java.util.ArrayList;
import java.util.Scanner;


public class ArrayListToJsonUsingGson {
  public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);
      ArrayList<String> products = new ArrayList<>();
        // Getting number of products from user input
  System.out.print("Enter number of products: ");
  int n = scanner.nextInt();
  scanner.nextLine();


  // Getting products from user input and adding them to ArrayList
  for (int i = 0; i < n; i++) {
      System.out.print("Enter product " + (i + 1) + ": ");
      String product = scanner.nextLine();
      products.add(product);
  }
  // Creating Gson object
  Gson gson = new Gson();


  // Converting ArrayList to JSON format using Gson
  String json = gson.toJson(products);


  // Printing the JSON format
  System.out.println("JSON format: " + json);
}
}

Output:

Enter number of products: 3
Enter product 1: Laptop
Enter product 2: Smartphone
Enter product 3: Headphones
JSON format: ["Laptop","Smartphone","Headphones"]

Sample problem 5

Suppose you are building a web application for a travel agency. You need to transform an ArrayList list of tour packages into a JSON format so that it can be displayed on the website.

Solution using Jackson library:

First, You must incorporate the Jackson library into your plan. If you’re working with Maven, you may achieve this by including the ensuing dependency in your pom.xml file:

Xml

<dependency>

    <groupId>com.fasterxml.jackson.core</groupId>

    <artifactId>jackson-databind</artifactId>

    <version>2.13.0</version>

</dependency>

Or by downloading the jar file from the official website and adding it to your project’s classpath.

You can use the ObjectMapper class to transform your ArrayList to a JSON format once the Jackson library has been installed to your project.

Here are the steps involved:

  1. The code prompts the user to enter the number of tour packages to be entered and then reads the details of each package using a Scanner.
  2. The details of each tour package are stored as TourPackage objects in an ArrayList.
  3. The ObjectMapper class is used to create a JSON string representation of the ArrayList of TourPackage objects.
  4. The resulting JSON string is printed to the console.

The TourPackage class is a straightforward Java class that has getter and setter methods for each of the three private fields: name, description, and price. The ArrayListToJsonUsingJackson class creates instances of this class and populates them with data entered by the user.

Code:

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.Scanner;


public class ArrayListToJsonUsingJackson {
  public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);
     
      // Create an empty array list to hold TourPackage objects
      ArrayList<TourPackage> tourPackages = new ArrayList<>();
     
      System.out.print("Enter number of tour packages: ");
      int n = scanner.nextInt();
      scanner.nextLine();
     
      // Prompt the user to enter details for each tour package and add it to the array list
      for (int i = 0; i < n; i++) {
          System.out.println("Enter tour package " + (i + 1) + " details:");
          System.out.print("Name: ");
          String name = scanner.nextLine();
          System.out.print("Description: ");
          String description = scanner.nextLine();
          System.out.print("Price: ");
          double price = scanner.nextDouble();
          scanner.nextLine();
          tourPackages.add(new TourPackage(name, description, price));
      }
     
      // Create an ObjectMapper object to convert the array list to JSON
      ObjectMapper objectMapper = new ObjectMapper();
      String json = "";
     
      try {
          // Use the ObjectMapper object to convert the array list to JSON string
          json = objectMapper.writeValueAsString(tourPackages);
          System.out.println("JSON format: " + json);
      } catch (Exception e) {
          // If there's an error, print the error message
          System.out.println("Error: " + e.getMessage());
      }
  }
}


// Define a TourPackage class to hold information about a tour package
class TourPackage {
  private String name;
  private String description;
  private double price;


  // Constructor to create a new TourPackage object with the given parameters
  public TourPackage(String name, String description, double price) {
      this.name = name;
      this.description = description;
      this.price = price;
  }


  // Getter and setter methods for the TourPackage class properties
  public String getName() {
      return name;
  }


  public void setName(String name) {
      this.name = name;
  }


  public String getDescription() {
      return description;
  }


  public void setDescription(String description) {
      this.description = description;
  }


  public double getPrice() {
      return price;
  }


  public void setPrice(double price) {
      this.price = price;
  }
}

Output:

Enter number of tour packages: 2
Enter tour package 1 details:
Name: Bali Tour
Description: Explore the beauty of Bali with our Bali tour package.
Price: 2000.50
Enter tour package 2 details:
Name: Paris Tour
Description: Experience the romance of Paris with our Paris tour package.
Price: 3000.75
JSON format: [{"name":"Bali Tour","description":"Explore the beauty of Bali with our Bali tour package.","price":2000.5},{"name":"Paris Tour","description":"Experience the romance of Paris with our Paris tour package.","price":3000.75}]

Conclusion:

We discussed ArrayList and JSONArray in Java, their definitions and purposes. We also talked about the importance of converting an ArrayList to a JSONArray in Java, which can be necessary in scenarios where we need to serialize or transmit data in JSON format.

We went through five different methods to perform this conversion.

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.