Let us assume that the class is Data with two objects name and dob which are both strings.

Initially, check if the list is empty. Then, add the objects from the list to a JSONArray

JSONArray allDataArray = new JSONArray();
List<Data> sList = new ArrayList<String>();

    //if List not empty
    if (!(sList.size() ==0)) {

        //Loop index size()
        for(int index = 0; index < sList.size(); index++) {
            JSONObject eachData = new JSONObject();
            try {
                eachData.put("name", sList.get(index).getName());
                eachData.put("dob", sList.get(index).getDob());
            } catch (JSONException e) {
                e.printStackTrace();
            }
            allDataArray.put(eachData);
        }
    } else {
        //Do something when sList is empty
    }
    

Finally, add the JSONArray to a JSONObject.

JSONObject root = new JSONObject();
    try {
        root.put("data", allDataArray);
    } catch (JSONException e) {
        e.printStackTrace();
    }

You can further get this data as a String too.

String jsonString = root.toString();

For a Json to be a valid JsonArray object you should have it to a proper format. Can you change your json string return from your ajax? If yes you should change it to something like this:

Gson googleJson = new Gson();
JsonObject data = googleJson.fromJson("{test: [{\"0\":\"31/01/2017\"},{\"1\":\"19/01/2017\"}]}", JsonObject.class);
System.out.println(data);
JsonArray jsonArr = data.getAsJsonArray("test");

ArrayList jsonObjList = googleJson.fromJson(jsonArr, ArrayList.class);
for(int i=0; i< jsonObjList.size(); i++) {
    System.out.println(jsonObjList.get(i));
}

If not you should parse it by your self and convert it to everything you want.

Yo should post what the json data looks like. Assuming the json data looks something like

...,{
    "image_data": {
        "name": "image name","thumb":"thumbpath","path":"path"}
},{
    "image_data": {
        "name": "image name 2","thumb":"thumbpath 2","path":"path 2"}
}

Then you would extract the values like so:

    ArrayList<image_data> imageArray = new ArrayList<image_data>();

         for (int i=0; i<jsonArray.length(); i++) {
             image_data img = new image_data();

             Object jo = jsonArray.get(i);

             image_data.name = jo.name;
             image_data.thumb = jo.thumb;
             image_data.path = jo.path;

             imageArray.add(new image_data());

         }

Consider using getters for you image_data class. Also consider renaming it to ImageData

I suggest

 JSONObject jo = new JSONObject();


 JSONArray ja = new JSONArray();

    try {
        Statement ac = DBL.getConnection().createStatement();
        ResultSet r5 = ac.executeQuery("Select * from msg");
        while(r5.next()){

            System.out.println("Value taken from database"+r5.getString("content"));
            JSONObject element = new JSONObject();

            element.put("Description", r5.getString("content"));
            element.put("Id", r5.getString("id"));
            element.put("Issent",r5.getString("issent"));
            ja.put(element);    
       }

       jo.put( "List", ja );
       System.out.println(jo.toString());
       ret= jo.toString();

For any one who looks for answer yet:

1.Add jackson-databind library to your build tools like Gradle or Maven

2.in your Code:

ObjectMapper mapper = new ObjectMapper();

List<Student> studentList = new ArrayList<>();

studentList = Arrays.asList(mapper.readValue(jsonStringArray, Student[].class));

Here is a functional way of creating an arrayNode and populate it elements from a stream. It does the same as above fracz answer :

    yourStringList.stream()
        .collect(Collector.of(
            () -> row.putArray("myList"), 
            (arrayNode, item) -> arrayNode.add(item), 
            (arrayNode1, arrayNode2) -> { arrayNode1.addAll(arrayNode2);  return arrayNode1; },
            Collector.Characteristics.IDENTITY_FINISH
        ));

Essentially, it defines a custom collector to accumulate the elements provided by the stream. Some explanations:

• the first argument () -> row.putArray("myList") defines the function which will provide the object to accumulate the items (called the supplier function). In our case this function will provide the ArrayNode and is the equivalent of ArrayNode arrayNode = row.putArray("myList"); statement in the above answer.
• the second argument (arrayNode, item) -> arrayNode.add(item) defines the accumulator function whose role is to add the elements. In the left side of the -> operator, the first variable (e.g. arrayNode) refers to the container defined in the first argument while the second (e.g. item) refers to the element to accumulate provided by the stream. This function does the same job as the statement arrayNode.add(item); inside the loop in the above example.
• the third argument (arrayNode1, arrayNode2) -> { arrayNode1.addAll(arrayNode2); return arrayNode1; } is the combiner function which is used if the stream is collected in parralel (for instance if we had .parralelStream() instead of .stream()). Its role is to merge two accumulators toghether and this is why the function has two argumets of the same type. We define this function such that it will add all elements accumulated in the second accumulator into the first accumulator and return this first accumulator.
• the fourth argument Collector.Characteristics.IDENTITY_FINISH define one or more optons to the process. In this case, IDENTITY_FINISH simply states that no finisher function will be provided (to further process the accumulator object) or, in other words, that the finisher function is the identity function (no treatment done).

This solution might seems more complex at first but it leverages all the power of functionnal programming. For instance, we could stream objects, extract a String property with the map function, filter it, etc. before collecting everything:

    yourObjectList.stream()
        .map(o -> o.getTheStringProperty())
        .filter(o -> o.length() > MIN_SIZE)
        .collect(Collector.of(
            () -> row.putArray("myList"), 
            (arrayNode, item) -> arrayNode.add(item), 
            (arrayNode1, arrayNode2) -> { arrayNode1.addAll(arrayNode2);  return arrayNode1; },
            Collector.Characteristics.IDENTITY_FINISH
        ));

You need an external library for this.

JSONArray jsonA = JSONArray.fromObject(mybeanList);
System.out.println(jsonA);

Google GSON is one of such libraries

You can also take a look here for examples on converting Java object collection to JSON string.

The answer is to use a JSONArray as well, and to dive "deep" into the tree structure:

JSONArray arr = new JSONArray();
arr.put (...); // a new JSONObject()
arr.put (...); // a new JSONObject()

JSONObject json = new JSONObject();
json.put ("aoColumnDefs",arr);

Here is the piece of code which you need

package uk.co.vishal;

import com.fasterxml.jackson.core.JsonProcessingException;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Answer {

public static void main(String[] args) throws JsonProcessingException {
    List<String> data = new ArrayList<>();
    data.add("user");
    data.add("car");
    data.add("brand");

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

    Map<String, String> mydata = new HashMap<>();
    Map<String, JSONObject> newdata = new HashMap<>();
    JSONObject result = new JSONObject();
    boolean flag = true;

    for (int i = data.size() - 1; i >= 0; i--) {
        if (flag) {
            mydata.put(data.get(i), "BMW");
            result = generateJson(mydata);
            flag = false;
        } else {
            newdata.put(data.get(i), result);
            result = generateJson(newdata);
            newdata.clear();
        }
    }
    System.out.println(result);
    /*
    * Here is the output:
    * {
        "user": {
            "car": {
                    "brand": "BMW"
                }
            }
      }
    *
    * */
}

private static JSONObject generateJson(Map data) {
    return new JSONObject(data);
}

}

I hope you will be sorted !!

1. Use any JSON parsor eg: GSON to create an arraylist of this particular json
2. Iterate the arraylist
3. Save it :)

You will have to include the jettison jar in you project and import the required classes.

JSONObject jObject = new JSONObject();
try
{
    JSONArray jArray = new JSONArray();
    for (Student student : sudentList)
    {
         JSONObject studentJSON = new JSONObject();
         studentJSON.put("name", student.getName());
         studentJSON.put("age", student.getAge());
         jArray.put(studentJSON);
    }
    jObject.put("StudentList", jArray);
} catch (JSONException jse) {
    jse.printStacktrace();
}