Question

我有这段代码旨在使用 CHUNK_SIZE 作为拆分的大小（以字节为单位）将字符串拆分为字符串数组（我这样做是为了对结果进行分页）。当字符为 1 个字节时，这在大多数情况下有效，但是当我在拆分位置有一个多字节字符（例如 2 字节法语字符（如 é）或 4 字节中文字符）时，我最终得到在我的第一个数组元素的末尾和第二个元素的开头有 2 个不可读的字符。

有没有办法修复代码以考虑多字节字符，以便在最终结果中保留它们？

public static ArrayList<String> splitFile(String data) throws Exception {
    ArrayList<String> messages = new ArrayList<>();
    int CHUNK_SIZE = 400000;// 0.75mb

    if (data.getBytes().length > CHUNK_SIZE) {
        byte[] buffer = new byte[CHUNK_SIZE];
        int start = 0, end = buffer.length;
        long remaining = data.getBytes().length;
        ByteArrayInputStream inputStream =
                new ByteArrayInputStream(data.getBytes());

        while ((inputStream.read(buffer, start, end)) != -1) {
            ByteArrayOutputStream outputStream =
                    new ByteArrayOutputStream();
            outputStream.write(buffer, start, end);
            messages.add(outputStream.toString("UTF-8"));
            remaining = remaining - end;

            if (remaining <= end) {
                end = (int) remaining;
            }
        }
        return messages;
    }

    messages.add(data);
    return messages;
}

Answer 1

你想：

计数字符而不是字节
对块大小和词边界敏感度使用正则表达式
少写代码

因此，

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 个字符，然后是单词边界”

不确定您是否真的需要返回列表。您可以从拆分中返回字符串数组。

Answer 2

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 代码点、符号是两个 (UTF-16) 字符。

Answer 3

由于您这样做是为了对结果进行分页，因此不按字符而是按单词拆分此文本可能会很有用。您可以遍历此 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.

^{另见：How to split a string after a certain length? But it should be divided after word completion}

将包含多字节字符的字符串拆分为字符串数组

3 个答案: