This is a working example based (and tested) with gson-2.8.0. It accepts an arbitrary sequence of JSON objects on a given input stream. And, of course, it does not impose any restrictions on how you have formatted your input:

       InputStream is = /* whatever */
       Reader r = new InputStreamReader(is, "UTF-8");
       Gson gson = new GsonBuilder().create();
       JsonStreamParser p = new JsonStreamParser(r);

       while (p.hasNext()) {
          JsonElement e = p.next();
          if (e.isJsonObject()) {
              Map m = gson.fromJson(e, Map.class);
              /* do something useful with JSON object .. */
          }
          /* handle other JSON data structures */
       }

Your json fragment is invalid - the last comma breaks the parsing. But the rest of the code is quite workable.

    String res = "[\n" +
            "    {\n" +
            "        \"Class\": \"1\",\n" +
            "        \"school\": \"test\",\n" +
            "        \"description\": \"test\",\n" +
            "        \"student\": [\n" +
            "            \"Student1\",\n" +
            "            \"Student2\"\n" +
            "        ],\n" +
            "        \"qualify\": true,\n" +
            "        \"annualFee\": 3.00\n" +
            "       }\n" +
            "]";

    JSONArray arr = new JSONArray(res);
    for (int i = 0; i < arr.length(); i++) {
        JSONObject block = arr.getJSONObject(i);
        Integer cls = block.getInt("Class");
        System.out.println("cls = " + cls);
        Object school = block.getString("school");
        System.out.println("school = " + school);
        JSONArray students = block.getJSONArray("student");
        System.out.println("student[0] = " + students.get(0));
        System.out.println("student[1] = " + students.get(1));
    }

should output

cls = 1
school = test
student[0] = Student1
student[1] = Student2

What you're doing is the correct way to do it. JSON calls always return one object.

The object you got back is an array, so you can extract the elements like this:

var myResponse = makeJSONCall();

// You have received myResponse.length objects, you can bind them
// to variables if you want

var thingOne = myResponse[0];
var thingTwo = myResponse[1];
...

// You can use them from their variable names or straight from the array

thingOne.name = "Joe Bob";
myResponse[3].status = "Tired";

You need a class that represents your json structure:

  class Person {
    private String name;
    private int age;
  }

  class PersonMap {
    private Map<String, Person> people;
  }

  @Test
  public void test() {
    String json =
        "{\r\n"
            + "\"people\":{\r\n"
            + "      \"1\": {\r\n"
            + "          \"name\": \"A\",\r\n"
            + "          \"age\": 5\r\n"
            + "         },\r\n"
            + "      \"2\": {\r\n"
            + "          \"name\": \"B\",\r\n"
            + "          \"age\": 6\r\n"
            + "         },\r\n"
            + "      \"3\": {\r\n"
            + "          \"name\": \"C\",\r\n"
            + "          \"age\": 7\r\n"
            + "         }\r\n"
            + "}\r\n"
            + "}";

    Gson gson = new GsonBuilder().setPrettyPrinting().create();

    var persons = gson.fromJson(json, PersonMap.class).people.values();
    for (Person person : persons) {
      System.out.println(person.name + " " + person.age);
    }
  }

Java variable names cannot be constructed dynamically.

I don't know how no one has answered this yet but here you are.

JSONObject objects = new JSONObject[10];
for(int i = 0 ; i < objects.length ; i++) {
    objects[i] = new JSONObject();
}

JSONObject o = objects[2]; // get the third one

Arrays are not dynamically resizable. You should use an appropriate List implementation if you need such behavior. If you want to access the elements by name, you can also use a Map.

Map<String, JSONObject> map = new HashMap<>();
for(int i = 0 ; i < 10 ; i++) {
    map.put("tempName" + i, new JSONObject());
}

JSONObject o = map.get("tempName3"); // get the 4th created (hashmaps don't have an ordering though)

If you are trying to read from features only, first you need to read the whole file as an object. Then you can, read the array part in the following way:

Object object = parser.parse(new FileReader("C:/Users/Zonoid/Desktop/EQ.json"));
JSONObject jasonObject = (JSONObject) object;
JSONArray features = (JSONArray) jasonObject.get("features");

Have you should try to use a framework like jackson Who will let unmarshall your json to real java object of your choice for example :

public class Data
{
   private String blukiiId;
   private String macAddress;
   private String type;
   ...
   private List<RSSI> rssi;
   private BeaconSensorData beaconSensorData;
}

With Rssi,BeaconSensorData another class like that etc... Now your code will get Converted as below

public class getJSON
{
   
   public static void main(String[] args) throws Exception{
       ObjectMapper mapper = new ObjectMapper();
       // Set any extra configs like ignore fields etc here

       try{
            Data data = mapper.convertValue(Files.readAllBytes(Paths.get("test.json"), Data.class);

            //Now you can access the value as below
            data.getBeaconSensorData().getEnvironment().getTemperature();
        }catch(Exception e){
            e.printStackTrace();
        }
        
    }
}

If you want a new object with two keys, Object1 and Object2, you can do:

JSONObject Obj1 = (JSONObject) jso1.get("Object1");
JSONObject Obj2 = (JSONObject) jso2.get("Object2");
JSONObject combined = new JSONObject();
combined.put("Object1", Obj1);
combined.put("Object2", Obj2);

If you want to merge them, so e.g. a top level object has 5 keys (Stringkey1, ArrayKey, StringKey2, StringKey3, StringKey4), I think you have to do that manually:

JSONObject merged = new JSONObject(Obj1, JSONObject.getNames(Obj1));
for(String key : JSONObject.getNames(Obj2))
{
  merged.put(key, Obj2.get(key));
}

This would be a lot easier if JSONObject implemented Map, and supported putAll.

I think the json string you provided should be like

"{\"bills\":[{\"amount\":\"13\",\"billId\":\"billid3\"} ,{\"amount\":\"155\",\"billId\":\"billid4\"}]}"

If this is the case, you can use the solution below:

Create two classes Bill.java and TestObject.java as follows:

Bill.java

public class Bill {
    private double amount;
    private String billId;
    /**
     * @return the amount
     */
    public double getAmount() {
        return amount;
    }
    /**
     * @param amount the amount to set
     */
    public void setAmount(double amount) {
        this.amount = amount;
    }
    /**
     * @return the billId
     */
    public String getBillId() {
        return billId;
    }
    /**
     * @param billId the billId to set
     */
    public void setBillId(String billId) {
        this.billId = billId;
    }

}

TestObject.java

import java.util.List;

public class TestObject {

    private List<Bill> bills;

    /**
     * @return the bills
     */
    public List<Bill> getBills() {
        return bills;
    }

    /**
     * @param bills the bills to set
     */
    public void setBills(List<Bill> bills) {
        this.bills = bills;
    }

}

Here is the main program to test the code.

Test.java

import com.fasterxml.jackson.databind.ObjectMapper;

public class Test {

    public static void main(String[] args) {
        String jsonStr = "{\"bills\":[{\"amount\":\"13\",\"billId\":\"billid3\"} ,{\"amount\":\"155\",\"billId\":\"billid4\"}]}";

        ObjectMapper mapper = new ObjectMapper();
        try {
            TestObject testObject = mapper.readValue(jsonStr, TestObject.class);
            System.out.print(testObject);
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}

I found very good link for JSON: http://code.google.com/p/json-simple/wiki/EncodingExamples#Example_1-1_-_Encode_a_JSON_object

Here's code to add multiple JSONObjects to JSONArray.

JSONArray Obj = new JSONArray();
try {
    for(int i = 0; i < 3; i++) {
        // 1st object
        JSONObject list1 = new JSONObject();
        list1.put("val1",i+1);
        list1.put("val2",i+2);
        list1.put("val3",i+3);
        obj.put(list1);
    }

} catch (JSONException e1) {
    // TODO Auto-generated catch block
    e1.printStackTrace();
}             
Toast.makeText(MainActivity.this, ""+obj, Toast.LENGTH_LONG).show();

On the outermost level, a JSON object starts with a { and end with a }.

Sample data:

{
    "cars": {
        "Nissan": [
            {"model":"Sentra", "doors":4},
            {"model":"Maxima", "doors":4},
            {"model":"Skyline", "doors":2}
        ],
        "Ford": [
            {"model":"Taurus", "doors":4},
            {"model":"Escort", "doors":4}
        ]
    }
}

If the JSON is assigned to a variable called data, then accessing it would be like the following:

data.cars['Nissan'][0].model   // Sentra
data.cars['Nissan'][1].model   // Maxima
data.cars['Nissan'][2].doors   // 2

for (var make in data.cars) {
    for (var i = 0; i < data.cars[make].length; i++) {
        var model = data.cars[make][i].model;
        var doors = data.cars[make][i].doors;
        alert(make + ', ' + model + ', ' + doors);
    }
}

Another approach (using an associative array for car models rather than an indexed array):

{
    "cars": {
        "Nissan": {
            "Sentra": {"doors":4, "transmission":"automatic"},
            "Maxima": {"doors":4, "transmission":"automatic"}
        },
        "Ford": {
            "Taurus": {"doors":4, "transmission":"automatic"},
            "Escort": {"doors":4, "transmission":"automatic"}
        }
    }
}

data.cars['Nissan']['Sentra'].doors   // 4
data.cars['Nissan']['Maxima'].doors   // 4
data.cars['Nissan']['Maxima'].transmission   // automatic

for (var make in data.cars) {
    for (var model in data.cars[make]) {
        var doors = data.cars[make][model].doors;
        alert(make + ', ' + model + ', ' + doors);
    }
}

Edit:

Correction: A JSON object starts with { and ends with }, but it's also valid to have a JSON array (on the outermost level), that starts with [ and ends with ].

Also, significant syntax errors in the original JSON data have been corrected: All key names in a JSON object must be in double quotes, and all string values in a JSON object or a JSON array must be in double quotes as well.

See:

• JSON specification
• JSONLint - The JSON validator

String.valueOf(gameService.convertLikesToJsonArray(averageLikesPerGame)); 

You are making this a single value in the json, instead of it being actual json. That's why it's all escaped in your JSON output. You also haven't shown your pretty print method, so can't comment on the output of that. Try

    //Use object instead of String as you want nested objects in output
    Map<String, Object> report = new HashMap<>();

    String highestRankedGame = gameService.findHighestRatedGame();
    String userWithMostComments = gameService.findUserWithMostComments();
    Map<String,String> averageLikesPerGame = gameService.findAverageLikesPerGame();

    report.put("highest_rated_game",highestRankedGame);
    report.put("user_with_most_comments", userWithMostComments);
   //Add averageLikesPerGame directly to report without modifying
    report.put("average_likes_per_game",averageLikesPerGame.entrySet());

    String jsonReport = gameService.convertReportToJson(report);

    return jsonReport;

And

public String convertReportToJson(Map<String, Object> report) {

    ObjectMapper mapper = new ObjectMapper();
    String jsonArray = null;
    try {
        //Don't need Gson, can use writerWithDefaultPrettyPrinter with Jackson which 
        //You are already using
        jsonArray = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(report);
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    return jsonArray;
}

If you want mapped values in the array with labels then you could do something like this

    List<Map<String,String>> labelledAvgLikesPerGame =
            averageLikesPerGame.entrySet().stream()
                    .map( entry ->
                           //Needs java 9+ for ofEntries
                           //You'll need to make new HashMap,put + return
                           // for java 8
                            Map.ofEntries(
                                    Map.entry("title", entry.getKey()),
                                    Map.entry("average_likes", entry.getValue())
                            )).collect(Collectors.toList());

    report.put("highest_rated_game",highestRankedGame);
    report.put("user_with_most_comments", userWithMostComments);
    report.put("average_likes_per_game",labelledAvgLikesPerGame);

Use this code and Enjoy :)

private void createJsonStructure() {

    try
    {
        JSONObject rootObject = new JSONObject();

        JSONArray carArr = new JSONArray();
        for (int i = 0; i < 2 ; i++)
        {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("CarId", "123");
            jsonObject.put("Status", "Ok");
            carArr.put(jsonObject);
        }
        rootObject.put("Car", carArr);


        JSONArray motorArr = new JSONArray();
        for (int i = 0; i < 2 ; i++)
        {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("MotorId", "123");
            jsonObject.put("Status", "Ok");
            motorArr.put(jsonObject);
        }
        rootObject.put("Motor", motorArr);


        JSONArray busArr = new JSONArray();
        for (int i = 0; i < 2 ; i++)
        {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("BusId", "123");
            jsonObject.put("Status", "Ok");
            busArr.put(jsonObject);
        }
        rootObject.put("Bus", busArr);

        Log.e("JsonObject", rootObject.toString(4));

    }
    catch (Exception ex)
    {
        ex.printStackTrace();
    }
}