The whole file is an array and there are objects and other arrays (e.g. cars) in the whole array of the file.

As you say, the outermost layer of your JSON blob is an array. Therefore, your parser will return a JSONArray. You can then get JSONObjects from the array ...

  JSONArray a = (JSONArray) parser.parse(new FileReader("c:\\exer4-courses.json"));

  for (Object o : a)
  {
    JSONObject person = (JSONObject) o;

    String name = (String) person.get("name");
    System.out.println(name);

    String city = (String) person.get("city");
    System.out.println(city);

    String job = (String) person.get("job");
    System.out.println(job);

    JSONArray cars = (JSONArray) person.get("cars");

    for (Object c : cars)
    {
      System.out.println(c+"");
    }
  }

For reference, see "Example 1" on the json-simple decoding example page.

You can use the below methods to read from a file and convert the JSON array to a List of Questions.

public String readJsonFromFile(String filePath) throws IOException, ParseException {
    String json = Files.readString(Paths.get("file path"));
    return new JSONParser().parse(json).toString();
}


public List<Question> convert(String JsonString) throws JsonMappingException, JsonProcessingException {
        ObjectMapper om = new ObjectMapper();
        CollectionType typeReference =
                TypeFactory.defaultInstance().constructCollectionType(List.class, Question.class);
        List<Question> questions =  om.readValue(JsonString, typeReference);
        return questions;
    }

If your JSON keys and Java class fields are different, use @JsonPropery annotation to map keys to fields

import com.fasterxml.jackson.annotation.JsonProperty;

public class Question {
    

    @JsonProperty("question")
    private String title;
    @JsonProperty("answer 1")
    private String a1;
    @JsonProperty("answer 2")
    private String a2;
    @JsonProperty("answer 3")
    private String a3;
    @JsonProperty("correct answer")
    private String cA;

    //setters & getters
}

Required Jars:
jackson-annotations.jar
jackson-core.jar
jackson-databind.jar
json-simple.jar //used to parse Json file to String

There are lots of API's and libraries are present but I prefer to use org.json API suggested by json.org

you can also go for GSON library which is one of the best library for serialize and deserialize Java objects to (and from) JSON.

here's the quick demo of reading above JSON with org.json API.

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

public class HelloWorld {
    public static void main(String[] args) {
        String jsonString = "[ { \"name\": \"Andrew\", \"age\": 21, \"parents\": [ { \"name\": \"Joseph\", \"age\": 18 }, { \"name\": \"Joseph\", \"age\": 18 } ] }, { \"name\": \"Maria\", \"age\": 35, \"parents\": [ { \"name\": \"Kassandra\", \"age\": 16 }, { \"name\": \"Abigail\", \"age\": 22 } ] } ]";
        JSONArray json = new JSONArray(jsonString);
        for(int i=0; i<json.length(); i++){
          JSONObject j = json.getJSONObject(i);
          System.out.println(j + "\n------");
        }
    }
}

You are asking Jackson to parse a StudentList. Tell it to parse a List (of students) instead. Since List is generic you will typically use a TypeReference

List<Student> participantJsonList = mapper.readValue(jsonString, new TypeReference<List<Student>>(){});

If you want to read two objects as a list into Java, you need to write them as a list as well:

List<Town> towns = new ArrayList<>();
towns.add(townobj);
towns.add(anotherTownobj);

writer.writeValue(out, towns);

When you read that back it becomes a List again.

The output you've shown in your question as not a valid single json file. But using the above method will get you a valid single json file that looks like this:

[
    {
      "p" : {
        "firstName" : "John",
        "amount" : 6860.0,
        "lastName" : "Smith"
      },
      "hello" : "qwiejiowcqnio",
      "number" : 1380.0
    },
    {
      "p" : {
        "firstName" : "Sam",
        "amount" : 623460.0,
        "lastName" : "Smith"
      },
      "hello" : "qwiej2342io",
      "number" : 1330.0
    }
]

Definitely the easiest way to do that is using Gson's default parsing function fromJson().

There is an implementation of this function suitable for when you need to deserialize into any ParameterizedType (e.g., any List), which is fromJson(JsonElement json, Type typeOfT).

In your case, you just need to get the Type of a List<String> and then parse the JSON array into that Type, like this:

import java.lang.reflect.Type;
import com.google.gson.reflect.TypeToken;

JsonElement yourJson = mapping.get("servers");
Type listType = new TypeToken<List<String>>() {}.getType();

List<String> yourList = new Gson().fromJson(yourJson, listType);

In your case yourJson is a JsonElement, but it could also be a String, any Reader or a JsonReader.

You may want to take a look at Gson API documentation.

You should definitly have a look at the Jackson Streaming API (https://www.baeldung.com/jackson-streaming-api). I used it myself for GB large JSON files. The great thing is you can divide your JSON into several smaller JSON objects and then parse them with mapper.readTree(parser). That way you can combine the convenience of normal Jackson with the speed and scalability of the Streaming API.

Related to your problem:

I understood that your have a really large array (which is the reason for the file size) and some much more readable objects:

e.g.:

[ // 40GB
{}, // Only 400 MB
{},
]

What you can do now is to parse the file with Jackson's Streaming API and go through the array. But each individual object can be parsed as "regular" Jackson object and then processed easily.

You may have a look at this Use Jackson To Stream Parse an Array of Json Objects which actually matches your problem pretty well.