Java 9 takeWhile和dropWhile读取和跳过某些行

本文介绍了Java 9 takeWhile和dropWhile读取和跳过某些行的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

我有一个文本文件，其中包含多个报告.每个报告均以文字"REPORT ID"开头，并具有特定值，即ABCD.对于简单的情况，我只想提取那些具有例如ABCD值的报表的数据.而且出于复杂性，我只想提取那些具有TAG1值(第二行)的报告的数据，即1000375351，并且报告值与ABCD相同.

I have a text file that contains multiple reports in it. Each report starts with a literal "REPORT ID" and have a specific value i.e ABCD.For simple case, I want to extract data of only those reports which have their value ABCD for example. And for complexity, I want to extract data of only those reports which have TAG1 value (2nd line)as 1000375351 and report value is same as ABCD.

我已经用传统方式做到了.我的decideAndExtract(String line)函数具有所需的逻辑.但是如何使用Java 9流的takeWhile和dropWhile方法来有效地处理它?

I have done it using traditional way. My decideAndExtract(String line) function have the required logic. But how can I use Java 9 streams takeWhile and dropWhile methods to efficiently deal with it?

try (Stream<String> lines = Files.lines(filePath)) {
    lines.forEach(this::decideAndExtract);
}

示例文本文件数据:

REPORT ID: ABCD
TAG1: 1000375351 PR
DATA1: 7399910002 T
DATA2: 4754400002 B
DATA3     : 1000640
Some Lines Here
REPORT ID: WXYZ
TAG1: 1000375351 PR
DATA1: 7399910002 T
DATA2: 4754400002 B
DATA3     : 1000640
Some Lines Here
REPORT ID: ABCD
TAG1: 1000375351 PR
DATA1: 7399910002 T
DATA2: 4754400002 B
DATA3     : 1000640
Some Lines Here

推荐答案

无论何时需要对文件使用Stream，似乎都是Files.lines的常见反模式.实际上是必需的.

It seems to be a common anti-pattern to go for Files.lines, whenever a Stream over a file is needed, regardless of whether processing individual lines is actually needed.

需要对文件进行模式匹配时，选择的第一个工具应为 Scanner :

The first tool of your choice, when pattern matching over a file is needed, should be Scanner:

Pattern p = Pattern.compile(
    "REPORT ID: ABCD\\s*\\R"
   +"TAG1\\s*:\\s*(.*?)\\R"
   +"DATA1\\s*:\\s*(.*?)\\R"
   +"DATA2\\s*:\\s*(.*?)\\R"
   +"DATA3\\s*:\\s*(.*?)\\R"); // you can keep this in a static final field

try(Scanner sc = new Scanner(filePath, StandardCharsets.UTF_8);
    Stream<MatchResult> st = sc.findAll(p)) {

    st.forEach(mr -> System.out.println("found tag1: " + mr.group(1)
        + ", data: "+String.join(", ", mr.group(2), mr.group(3), mr.group(4))));
}

调整模式很容易，即使用

It's easy to adapt the pattern, i.e. use

Pattern p = Pattern.compile(
    "REPORT ID: ABCD\\s*\\R"
   +"TAG1: (1000375351 PR)\\R"
   +"DATA1\\s*:\\s*(.*?)\\R"
   +"DATA2\\s*:\\s*(.*?)\\R"
   +"DATA3\\s*:\\s*(.*?)\\R"); // you can keep this in a static final field

作为满足您更复杂条件的模式.

as pattern to fulfill your more complex criteria.

但是您还可以在Stream中提供任意过滤条件:

But you could also provide arbitrary filter conditions in the Stream:

Pattern p = Pattern.compile(
    "REPORT ID: (.*?)\\s*\\R"
   +"TAG1: (.*?)\\R"
   +"DATA1\\s*:\\s*(.*?)\\R"
   +"DATA2\\s*:\\s*(.*?)\\R"
   +"DATA3\\s*:\\s*(.*?)\\R"); // you can keep this in a static final field

try(Scanner sc = new Scanner(filePath, StandardCharsets.UTF_8);
    Stream<MatchResult> st = sc.findAll(p)) {

    st.filter(mr -> mr.group(1).equals("ABCD") && mr.group(2).equals("1000375351 PR"))
      .forEach(mr -> System.out.println(
          "found data: " + String.join(", ", mr.group(3), mr.group(4), mr.group(5))));
}

与示例中的equals调用相比，

允许更复杂的构造. (请注意，此示例中的组号已更改.)

allowing more complex constructs than the equals calls of the example. (Note that the group numbers changed for this example.)

例如，要支持报告ID"后数据项的可变顺序，您可以使用

E.g., to support a variable order of the data items after the "REPORT ID", you can use

Pattern p = Pattern.compile("REPORT ID: (.*?)\\s*\\R(((TAG1|DATA[1-3])\\s*:.*?\\R){4})");
Pattern nl = Pattern.compile("\\R"), sep = Pattern.compile("\\s*:\\s*");

try(Scanner sc = new Scanner(filePath, StandardCharsets.UTF_8);
    Stream<MatchResult> st = sc.findAll(p)) {

    st.filter(mr -> mr.group(1).equals("ABCD"))
      .map(mr -> nl.splitAsStream(mr.group(2))
          .map(s -> sep.split(s, 2))
          .collect(Collectors.toMap(a -> a[0], a -> a[1])))
      .filter(map -> "1000375351 PR".equals(map.get("TAG1")))
      .forEach(map -> System.out.println("found data: " + map));
}

findAll在Java 9中可用，但是如果必须支持Java 8，则可以使用的findAll实现.这个答案.

findAll is available in Java 9, but if you have to support Java 8, you can use the findAll implementation of this answer.

这篇关于Java 9 takeWhile和dropWhile读取和跳过某些行的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！