1

我正面临流dropWhile或takeWhile方法的问题，因为拆分器正在以奇数或偶数的特定模式跳过部分文本。应该如何处理文本的所有部分？我的方法在这里：

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

4

1 回答 1

2

应该如何处理文本的所有部分？

你可以选择不同的方法。

在显示您的问题后，您的代码在我的机器上产生了 StackOverflowError （也有一个调用，fetchNextChunk但有一个名为 的方法fetchNextPartition，所以我也不确定），所以我没有尝试调试它，而是想出了一个不同的方法分割输入。鉴于我的方法在内存中包含整个字符串，它可能不适合较大的文件。稍后我可能会使用 Streams 制定一个版本。

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

这个想法类似于您的方法，但不是基于 Spliterators 并且它也不使用 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"));
}

在上面完整代码示例的 Main 类中的某处。

于 2019-08-06T06:03:39.040 回答