Here is some code using java 6 to get you started:

JSONObject jo = new JSONObject();
jo.put("firstName", "John");
jo.put("lastName", "Doe");

JSONArray ja = new JSONArray();
ja.put(jo);

JSONObject mainObj = new JSONObject();
mainObj.put("employees", ja);

Edit: Since there has been a lot of confusion about put vs add here I will attempt to explain the difference. In java 6 org.json.JSONArray contains the put method and in java 7 javax.json contains the add method.

An example of this using the builder pattern in java 7 looks something like this:

JsonObject jo = Json.createObjectBuilder()
  .add("employees", Json.createArrayBuilder()
    .add(Json.createObjectBuilder()
      .add("firstName", "John")
      .add("lastName", "Doe")))
  .build();

Here is an approach using Jackson (I used version 2.11.1).

An "item" here is defined as one of the id/value pairs in the source JSON - for example:

{
  "id": "b61ffb48-ffc7-4ae6-81a2-78b632892fda",
  "value": "[email protected]"
}

I split the task into 2 parts:

1. Cut off the data when the required limit is reached, by deleting subsequent items.

2. Clean up any resulting empty objects or arrays.

Here is my input test data (based on the data provided in the question):

    private static final String JSON = "{\n"
            + " \"emails\": [{\n"
            + "         \"emails\": [{\n"
            + "             \"email\": {\n"
            + "                 \"id\": \"ac9e95cf-3338-4094-b465-e0e1deca23c4\",\n"
            + "                 \"value\": \"[email protected]\"\n"
            + "             }\n"
            + "         }]\n"
            + "     },\n"
            + "     {\n"
            + "         \"email\": {\n"
            + "             \"id\": \"b61ffb48-ffc7-4ae6-81a2-78b632892fda\",\n"
            + "             \"value\": \"[email protected]\"\n"
            + "         }\n"
            + "     }\n"
            + " ],\n"
            + " \"lastName\": {\n"
            + "     \"id\": \"ffe19ece-819b-4680-8e0b-8566b34c973d\",\n"
            + "     \"value\": \"LastName\"\n"
            + " },\n"
            + " \"firstName\": {\n"
            + "     \"id\": \"4ed234f4-f679-40f3-b76b-41d9fdef7390\",\n"
            + "     \"value\": \"FirstName\"\n"
            + " }\n"
            + "}";

The code:

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.util.Iterator;

public class JsonReducer {

    // get the first n "id/value" items:
    private final int limit = 2;
    // tracks how close we are to the cutoff limit:
    private int counter = 0;

    public void doParsing() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode json = mapper.readValue(JSON, JsonNode.class);
        
        // show the input JSON formatted, just for this demo:
        System.out.println(json.toPrettyString());

        // a copy of the original - we will use this when cleaning up:
        JsonNode prevJson = json.deepCopy();
        // remove unwanted items from the JSON
        json = reduce(json);

        // clean up empty nodes resulting from removals:
        while (!json.equals(prevJson)) {
            prevJson = json.deepCopy();
            json = stripEmpty(json);
        }

        System.out.println("---------------------------------");
        System.out.println(json.toPrettyString());
    }

    private JsonNode reduce(JsonNode json) {
        for (JsonNode node : json) {
            if (node.isObject()) {
                counter++;
                //System.out.println("obj " + counter + " - " + node.toString());
                if (counter > limit) {
                    ((ObjectNode) node).removeAll();
                } else {
                    reduce(node);
                }
            } else if (node.isArray()) {
                ArrayNode arrayNode = (ArrayNode) node;
                //System.out.println("array - " + arrayNode.toString());
                arrayNode.forEach((item) -> {
                    // assume each item is a JSON object - no arrays of arrays:
                    ObjectNode objectNode = (ObjectNode) item;
                    reduce(objectNode);
                });
            } //else if (node.isTextual()) {
            //System.out.println("text  - " + node.asText());
            //}
        }
        return json;
    }

    private JsonNode stripEmpty(JsonNode json) {
        Iterator<JsonNode> it = json.iterator();
        while (it.hasNext()) {
            JsonNode child = it.next();
            if (child.isContainerNode() && child.isEmpty()) {
                it.remove(); // remove empty arrays [], and objects {}
            } else {
                stripEmpty(child);
            }
        }
        return json;
    }

    private static final String JSON = ... // as shown above.

}

The reduce() method recursively iterates through the JSON, keeping track of the number of items collected - and then deletes any in excess of the required number.

However, this can leave empty [] arrays or {} objects in the JSON, so the stripEmpty() method handles that.

Because we are iterating sequentially through the JSON from top to bottom and from outer to inner, it's possible that we may need more than one pass of the stripEmpty() method. There may be a more efficient approach, which only needs one pass, but this is approach is at least straightforward.

Examples of the results:

For limit = 2:

{
  "emails" : [ {
    "emails" : [ {
      "email" : {
        "id" : "ac9e95cf-3338-4094-b465-e0e1deca23c4",
        "value" : "[email protected]"
      }
    } ]
  }, {
    "email" : {
      "id" : "b61ffb48-ffc7-4ae6-81a2-78b632892fda",
      "value" : "[email protected]"
    }
  } ]
}

For limit = 1:

{
  "emails" : [ {
    "emails" : [ {
      "email" : {
        "id" : "ac9e95cf-3338-4094-b465-e0e1deca23c4",
        "value" : "[email protected]"
      }
    } ]
  } ]
}

For limit = 0:

{ }

Additional Points:

Not Generic

The approach assumes there are never any arrays nested directly inside other arrays - so none of this: [ [ {...} ] ]. In other words, this is not a 100% generic parser, but does have some limitations in line with the sample data in the question.

Consider using POJOs

This solution does not define any POJO java objects into which the data is loaded - but it can often be easier to get what you want by doing that:

• load (deserialize) the data into one or more POJOs.
• remove unwanted data from the POJOs.
• serialize the remaining data back to JSON.

If the example were any more complicated than the one in the question, I think I would favor doing this instead of manipulating only JsonNode data.

Update

Given the changes to the question, I think the best approach I can suggest is to parse each "item" (see definition above) into a POJO which would simply contain 3 fields:

String attribute;
String id;
String value;

The code to do this is as follows:

    private void traverse(JsonNode json) {
        Iterator<Map.Entry<String, JsonNode>> it = json.fields();
        while (it.hasNext()) {
            Map.Entry<String, JsonNode> entry = it.next();
            String name = entry.getKey();
            JsonNode node = entry.getValue();

            if (node.isArray()) {
                ArrayNode arrayNode = (ArrayNode) node;
                arrayNode.forEach((item) -> {
                    // assume each item is a JSON object - no arrays of arrays:
                    ObjectNode objectNode = (ObjectNode) item;
                    traverse(objectNode);
                });
            } else {
                String id = node.get("id").asText();
                String value = node.get("value").asText();
                
                System.out.println("attr : " + name);
                System.out.println("id   : " + id);
                System.out.println("value: " + value);
                System.out.println("---");
            }
        }
    }

Instead of the println() statements, you would create a new instance of the POJO and add it to an ArrayList.

Now you have a standard list containing all your data - and you can access items 1 - 100, then 101 - 200... and so on, as needed for the user interface.

You would need to convert that raw POJO data back to whatever format the UI needs/expects, of course.

Using the example JSON from the question, the above approach prints this:

attr : email
id   : ac9e95cf-3338-4094-b465-e0e1deca23c4
value: [email protected]
---
attr : email
id   : b61ffb48-ffc7-4ae6-81a2-78b632892fda
value: [email protected]
---
attr : lastName
id   : ffe19ece-819b-4680-8e0b-8566b34c973d
value: LastName
---
attr : firstName
id   : 4ed234f4-f679-40f3-b76b-41d9fdef7390
value: FirstName

Have you tried using JSONArray.getJSONObject(int), and JSONArray.length() to create your for-loop:

for (int i = 0; i < recs.length(); ++i) {
    JSONObject rec = recs.getJSONObject(i);
    int id = rec.getInt("id");
    String loc = rec.getString("loc");
    // ...
}