Instead of using the split function, you can convert your String to a JSONArray and then iterate throw the array

JSONArray jsonArray = new JSONArray(response.toString());
for(int i=0; i<jsonArray.length(); i++) {
    JSONObject jsonObject = jsonArray.getJSONObject(i);
    String jsonObjectAsString = jsonObject.toString();
}

You can use subList method:

import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonArrayBuilder;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class JsonApp {

    public static void main(String[] args) {
        List<Integer> ints = IntStream.range(1, 10).boxed().collect(Collectors.toList());
        JsonArrayExt array = new JsonArrayExt(ints);

        JsonArray array1 = array.subList(2, 5);
        System.out.println(array);
        System.out.println(array1);
    }
}

class JsonArrayExt {
    private final JsonArray array;

    public JsonArrayExt(List<Integer> ints) {
        this(Json.createArrayBuilder(ints).build());
    }

    public JsonArrayExt(JsonArray array) {
        this.array = Objects.requireNonNull(array);
    }

    public JsonArray subList(int fromIndex, int toIndex) {
        JsonArrayBuilder builder = Json.createArrayBuilder();
        array.subList(fromIndex, toIndex).forEach(builder::add);

        return builder.build();
    }

    @Override
    public String toString() {
        return array.toString();
    }
}

Above code prints:

[1,2,3,4,5,6,7,8,9]
[3,4,5]

Well, I'm a little ashamed to post this code. It's not optimal at all, looks awful, but probably it could lead you to right direction if you want completely unaltered content.

enum ParserState {
    READING_OBJECT,
    READING_ARRAY
}


public static List<String> extractObjects(String array) throws ParseException {
    ParserState state = ParserState.READING_ARRAY;
    ArrayList<String> result = new ArrayList<String>();
    StringBuilder currentObject = null;
    int i = 0;
    int parenthesisBalance = 0;
    for (char c : array.toCharArray()) {
        switch (c) {
            case '{': {
                if (state == ParserState.READING_ARRAY) {
                    state = ParserState.READING_OBJECT;
                    currentObject = new StringBuilder();
                }
                parenthesisBalance++;
                currentObject.append(c);
                break;
            }
            case '}': {
                if (state == ParserState.READING_ARRAY) {
                    throw new ParseException("unexpected '}'", i);
                } else {
                    currentObject.append(c);
                    parenthesisBalance--;
                    if (parenthesisBalance == 0) {
                        state = ParserState.READING_ARRAY;
                        result.add(currentObject.toString());
                    }
                }
                break;
            }
            default: {
                if (state == ParserState.READING_OBJECT) {
                    currentObject.append(c);
                }
            }
        }
        i++;
    }
    return result;
}

A nice solution for this problem is simply to iterate by using the Java 8 Streaming API:s. The JsonNode object is Iterable where the spliterator method is available. So, the following code can be used:

public List<String> split(final String jsonArray) throws IOException {
    final JsonNode jsonNode = new ObjectMapper().readTree(jsonArray);
    return StreamSupport.stream(jsonNode.spliterator(), false) // Stream
            .map(JsonNode::toString) // map to a string
            .collect(Collectors.toList()); and collect as a List
}

Another alternative is to skip the remapping (the call to toString) and return a List<JsonNode> elements instead. That way you can use the JsonNode methods to access the data (get, path and so on).

@VictorFaure Hello! You can read the data as a string, then use Java code to intercept the substring, and finally, use the tNormalize component to split the string into multiple rows. Java code on tJavaRow_1: //Code generated according to input schema and output schema output_row.body = (input_row.body.substring(input_row.body.indexOf(':')+1)).replaceAll('//[', '').replaceAll('//]', ''); output_row.body=output_row.body.replaceAll('//}, //{','//}; //{'); Hope it helps you! Regards Shicong

You can create an instance of org.json.JSONArray with server response:

String serverResponse = "YOUR STRING";
JSONArray serverJsonArray = new JSONArray(serverResponse);

And then fill products list:

ArrayList<String> products = new ArrayList<>(serverJsonArray.length());
for(int i = 0; i < serverJsonArray.length(); i++){
     products.add(serverJsonArray.getString(i));
}

---

Or if you absolutely want a String array:

String[] products = new String[serverJsonArray.length()];
for(int i = 0; i < serverJsonArray.length(); i++){
     products[i] = serverJsonArray.getString(i);
}

When processing huge input files, you should use a streaming approach instead of loading the whole document into memory, to reduce memory footprint, avoid OutOfMemoryError, and make it possible to start processing whie reading input. JSONArray has little support for streaming, so I would recommend looking into Jackson's streaming API, GSON streaming, or similar.

That being said, if you insist on using JSONArray, you can cobble together a streaming method by using JSONTokener. Here's a sample program that will stream an input file and create separate JSON documents with at most 10 elements each.

import java.io.*;
import java.util.*;
import org.json.*;

public class JsonSplit {

    private static final int BATCH_SIZE = 10;

    public static void flushFile(List<Object> objects, int d) throws Exception {
        try (FileOutputStream output = new FileOutputStream("split-" + d
            + ".json");
                Writer writer = new OutputStreamWriter(output, "UTF-8")) {
            JSONArray jsonArray = new JSONArray(objects);
            jsonArray.write(writer);
        }
    }

    public static void main(String[] args) throws Exception {
        int outputIndex = 0;
        try (InputStream input = new BufferedInputStream(
                new FileInputStream(args[0]))) {
            JSONTokener tokener = new JSONTokener(input);
            if (tokener.nextClean() != '[') {
                throw tokener.syntaxError("Expected start of JSON array");
            }
            List<Object> jsonObjects = new ArrayList<>();
            while (tokener.nextClean() != ']') {
                // Back up one character, it's part of the next value.
                tokener.back();
                // Read the next value in the array.
                jsonObjects.add(tokener.nextValue());
                // Flush if max objects per file has been reached.
                if (jsonObjects.size() == BATCH_SIZE) {
                    flushFile(jsonObjects, outputIndex);
                    jsonObjects.clear();
                    outputIndex++;
                }
                // Read and discard commas between array elements.
                if (tokener.nextClean() != ',') {
                    tokener.back();
                }
            }
            if (!jsonObjects.isEmpty()) {
                flushFile(jsonObjects, outputIndex);
            }
            // Verify that end of input is reached.
            if (tokener.nextClean() != 0) {
                throw tokener.syntaxError("Expected end of document");
            }
        }

    }

}

To see why a streaming approach is needed for huge files, download or create a huge JSON file, then try running a naive implementation that doesn't stream. Here's a Perl command to create a JSON array with 1,000,000 elements and a file size of around 16 MB.

perl -le 'print "["; for (1..1_000_000) {print "," unless $_ == 1; print "{\"id\": " . int(rand(1_000_000)) . "}";} print "]"' > input_huge.json

If you run JsonSplit on this input, it will churn away happily with a small memory footprint, producing 100,000 files with 10 elements in each. Also, it will begin producing output files immediately when started.

If, instead, you run the following JsonSplitNaive program, which reads the entire JSON document in one go, it will apparently do nothing for a long period, then abort with an OutOfMemoryError.

import java.io.*;
import java.util.*;
import org.json.*;

public class JsonSplitNaive {

    /*
     * Naive version - do not use, will fail with OutOfMemoryError for
     * huge inputs.
     */

    private static final int BATCH_SIZE = 10;

    public static void flushFile(List<Object> objects, int d) throws Exception {
        try (FileOutputStream output = new FileOutputStream("split-" + d
            + ".json");
                Writer writer = new OutputStreamWriter(output, "UTF-8")) {
            JSONArray jsonArray = new JSONArray(objects);
            jsonArray.write(writer);
        }
    }

    public static void main(String[] args) throws Exception {
        int outputIndex = 0;
        try (InputStream input = new BufferedInputStream(
                new FileInputStream(args[0]))) {
            List<Object> jsonObjects = new ArrayList<>();
            JSONArray jsonArray = new JSONArray(new JSONTokener(input));
            for (int i = 0; i < jsonArray.length(); i++) {
                jsonObjects.add(jsonArray.get(i));
                // Flush if max objects per file has been reached.
                if (jsonObjects.size() == BATCH_SIZE) {
                    flushFile(jsonObjects, outputIndex);
                    jsonObjects.clear();
                    outputIndex++;
                }
            }
            if (!jsonObjects.isEmpty()) {
                flushFile(jsonObjects, outputIndex);
            }
        }
    }

}

To split a json with many records into chunks of a desired size I simply use:

jq -c '.[0:1000]' mybig.json

which works like python slicing.

See the docs here: https://stedolan.github.io/jq/manual/

Array/String Slice: .[10:15]

The .[10:15] syntax can be used to return a subarray of an array or substring of a string. The array returned by .[10:15] will be of length 5, containing the elements from index 10 (inclusive) to index 15 (exclusive). Either index may be negative (in which case it counts backwards from the end of the array), or omitted (in which case it refers to the start or end of the array).

You could do something like this:

public static void main(String[] args) throws IOException {

    String summary = "";

    for(int a = 0; a<100000; a++) { 
        String current =  "\r\n" + new ObjectMapper().writeValueAsString(new MyClass());

        if((summary + current).getBytes("UTF-8").length>100000) {
            System.out.println("Overload 100 kb!");
             printFile(summary);
            summary = current;
        }
        else 
            summary = summary + "\r\n" + new ObjectMapper().writeValueAsString(new MyClass());
    } 
}

public static void printFile(String string) throws IOException {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd_HH_mm_ss_SSS"); 
    try(  PrintWriter out = new PrintWriter("C:\\Chunks\\" +sdf.format(new Date()) +".txt" )  ){
        out.println( string );
    }
}

Consider UTF-8 as a choice. Split happens taking count the byte[] lenght so 100000 byte are 100kb.

For the serialization I've used a standard Jackson approach, this is the maven dependency:

   <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.3</version>
</dependency>

...and finally the simple Pojo class:

public class MyClass implements Serializable{


    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    public String getField1() {
        return field1;
    }
    public void setField1(String field1) {
        this.field1 = field1;
    }
    public String getField2() {
        return field2;
    }
    public void setField2(String field2) {
        this.field2 = field2;
    }
    public MyClass() {
        super();
        // TODO Auto-generated constructor stub
    }
    private String field1;
    private String field2;
    //getter and setter
}

Let me know if it helps!