拆分器跳过部分文本

Question

我遇到了Streams的DropWhile或TakeWhile方法的问题，因为spliterator跳过特定模式（奇数或偶数）的文本部分。应该做什么来处理文本的所有部分？我在这里的方法：

void read(Path filePath) {
    try {
        Stream<String> lines = Files.lines(filePath);
        while (true) {
            Spliterator<String> spliterator = lines.dropWhile(line -> !line.startsWith("FAYSAL:")).spliterator();
            Stream<String> portion = fetchNextPortion(spliterator);
            if(spliterator.estimateSize() == 0)
                break;
            portion .forEach(System.out::println);
            lines = StreamSupport.stream(spliterator, false);
        }
        lines.close();
    }
    catch (IOException e) {
        e.printStackTrace();
    }
}

private Stream<String> fetchNextPortion(Spliterator<String> spliterator) {
    return StreamSupport.stream(spliterator, false)
            .filter(this::isValidReportName)
            .peek(System.out::println)
            .findFirst()
            .map( first -> Stream.concat(Stream.of(first),
                    StreamSupport.stream(spliterator, false).takeWhile(line -> !line.startsWith("FAYSAL:")))).orElse(Stream.empty());
}

示例输入为：

FAYSAL: 1
Some text here
Some text here
FAYSAL: 2
Some text here
Some text here
FAYSAL: 3
Some text here
Some text here
FAYSAL: 4
Some text here
Some text here

它将跳过Faysal:2和Faysal:4

Answer 1

应该做什么来处理文本的所有部分？

你可以选择一个不同的方法。

您的代码在我的计算机上产生了一个StackOverflowError（还有一个对FetchNextChunk的调用，但是一个名为FetchNextPartition的方法，所以我也不确定这一点），所以我没有尝试调试它，而是想出了一种不同的方法来拆分输入。鉴于我的方法在内存中包含整个字符串，它可能不适合较大的文件。我以后可能会用Streams开发出一个版本。

基本假设：您希望将输入文本分成几个部分，每个部分都以一个以“faysal：”开头的字符串开始。

这个想法与您的方法类似，但不是基于spliterator，也没有使用dropWhile。相反，它会找到以“faysal：”开头的第一个字符串（我假定这就是isValidReportName所做的；方法的代码不在问题中），并将所有内容处理到下一部分开始。将找到的第一个元素添加为列表的第一个元素，然后将集合添加到以后可以使用的列表中。然后从原始列表中删除收集的行数。

完整代码：

import java.util.*;
import java.util.stream.Collectors;

class Main {

    public static void main(String[] args) {
        Main m = new Main();
        System.out.println(m.partitionTextByStringStart(m.getString()));
    }

    private List<List<String>> partitionTextByStringStart(String text) {
        List<List<String>> partitions = new ArrayList<>();
        List<String> lines = Arrays.asList(text.split("\n"));

        while (!lines.isEmpty()) {
            String first = lines.stream().filter(this::isValidReportName).findFirst().orElse("This is prolly bad");
            List<String> part = lines.stream().skip(1).takeWhile(l -> !l.startsWith("FAYSAL:")).collect(Collectors.toList());
            part.add(0, first);

            partitions.add(part);
            lines = lines.subList(part.size(), lines.size());
        }

        return partitions;
    }

    private boolean isValidReportName(String x) {
        return x.startsWith("FAYSAL:");
    }

    private String getString() {
        return "FAYSAL: 1\n" +
                "Some text here1\n" +
                "Some text here1\n" +
                "FAYSAL: 2\n" +
                "Some text here2\n" +
                "Some text here2\n" +
                "FAYSAL: 3\n" +
                "Some text here3\n" +
                "Some text here3\n" +
                "FAYSAL: 4\n" +
                "Some text here4\n" +
                "Some text here4";
    }

}

（注意：我在这里使用了一个静态字符串，而不是文件读取来制作完整的代码示例；您可以相应地改编您的代码）

编辑：经过一些研究，我发现使用StreamEx（Github）（Maven）库将这些东西分组在流中是非常容易的。在这个答案中，我找到了一个关于streamex#groupruns函数的注释，该函数正是这样做的：

private Stream<Stream<String>> partitionStreamByStringStart(Stream<String> lineStream) {
    return StreamEx.of(lineStream).groupRuns((l1, l2) -> !l2.startsWith("FAYSAL:")).map(Collection::stream);
}

若要查看其工作情况，您可以添加

System.out.println(m.partitionStreamByStringStart(m.getStream()).map(
    s -> s.collect(Collectors.toList())
).collect(Collectors.toList()));

到主函数和

private Stream<String> getStream() {
    return Stream.of(getString().split("\n"));
}

在上面的完整代码示例的主类中的某个地方。