因为这样做是为了分页结果，所以不按字符而是按单词拆分文本可能很有用。您可以迭代这个 string 检查每一个单词是否至少有一半适合这一页，如果不适合，就开始新的一页。
一页行大小有限的示例。在多页文档中，它的工作原理与有限的页面大小相同：

String text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, " +
        "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. " +
        "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris " +
        "nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in " +
        "reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla " +
        "pariatur. Excepteur sint occaecat cupidatat non proident, sunt in " +
        "culpa qui officia deserunt mollit anim id est laborum.";

int length = 55;

ArrayList<String> lines = new ArrayList<>();

int lastWord = 0;
int lastLine = 0;
for (int i = 0; i < text.length(); i++) {
    if (text.charAt(i) == ' ') {
        if (i - lastLine + (i - lastWord) / 2 > length) {
            lines.add(text.substring(lastLine, i));
            lastLine = i + 1;
        }
        lastWord = i + 1;
    }
}
lines.add(text.substring(lastLine));

// output line by line
lines.forEach(System.out::println);

输出：

Lorem ipsum dolor sit amet, consectetur adipiscing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit
esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui
officia deserunt mollit anim id est laborum.

另请参阅：如何在一定长度后拆分字符串？但它应该在单词完成后分开

你想：
计数字符而不是字节
将regex用于块大小和字边界敏感度
少写代码
因此，

private static int CHUNK_SIZE = 400000;

public static ArrayList<String> splitFile(String data) {
    return Arrays.asList(data.split("(?s)(?<=\\G.{1," + CHUNK_SIZE + "}\\b) +"));
}

分解正则表达式： (?s 意思是“点应该匹配新行” \G 表示“最后匹配的结束”，并初始化为输入的开始 \b 意思是“单词边界” (?<=\G.{1,400000}\b) 意思是“在最后一个匹配结束之前，最多400000个字符，然后是一个单词边界”
不知道你是否真的需要一个列表返回。您可以直接从拆分中返回字符串数组。

public static List<String> splitFile(String data) throws IOException {
    List<String> messages = new ArrayList<>();
    final int CHUNK_SIZE = 400_000;// 0.75mb

    byte[] dataBytes = data.getBytes(StandardCharsets.UTF_8);
    byte[] buffer = new byte[CHUNK_SIZE];
    int start = 0;
    final int end = CHUNK_SIZE;
    ByteArrayInputStream inputStream = new ByteArrayInputStream(dataBytes);

    for (; ; ) {
        int read = inputStream.read(buffer, start, end - start);
        if (read == -1) {
            if (start != 0) {
                messages.add(new String(buffer, 0, start,
                        StandardCharsets.UTF_8));
            }
            break;
        }
        // Check for half read multi-byte sequences:
        int fullEnd = start + read;
        while (fullEnd > 0) {
            byte b = buffer[fullEnd - 1];
            if (b >= 0) { // ASCII.
                break;
            }
            if ((b & 0xC0) == 0xC0) { // Start byte of sequence.
                --fullEnd;
                break;
            }
            --fullEnd;
        }
        messages.add(new String(buffer, 0, fullEnd, StandardCharsets.UTF_8));
        start += read - fullEnd;
        if (start > 0) { // Copy the bytes after fullEnd to the start.
            System.arraycopy(buffer, fullEnd, buffer, 0, start);
            //               src     srcI     dest    destI len
        }
    }
    return messages;
}

我保留了bytearrayinputstream，就像大多数人从inputstream读取一样，而不是将所有字节都存储在内存中。
然后从 start 而不是从0开始，因为之前的块读取可能会留下一些字节。
reading给出读取的字节数或-1。
最后一个ascii字符是可以的，否则我把末尾放在多字节序列的开头。也许那个序列完全被读取了，也许没有。在这里，我只是把它留到下一块正在读。
这段代码没有看到编译器。
邮件列表对内存也不友好。
顺便说一句 char[] 人们也会遇到类似的问题，有时一个unicode码位symbol是两个（utf-16）字符。