Java 8 Streams: How to read lines between two lines specified by line content

Question

Input to the current problem statement is -

Input.txt

#START_OF_TEST_CASES

#DATA
key1:VA1
key2:VA2
key3:VA3
key4:VA4
key5:VA5
#DEND

#ENTRIES:
1{key1}{key1}{key3}
2{key2}{key2}{key1}
3{key3}{key1}{key2}
#EEND

Now I want to read this file and create a HashMap of the lines in between #DATA and #DEND. Key for the HashMap is the left part of ':' and value is the right part. Although we can achieve this iteratively I want to do this using Java 8's Stream APIs.

Answer 1

Unfortunately, Java 8 streams do not support such extraction of elements in-between two matches. In Java 9, you could use

Map<String,String> map;
try(Stream<String> stream = Files.lines(path)) {
    map = stream
        .dropWhile(s -> !s.equals("#DATA")).skip(1)
        .takeWhile(s -> !s.equals("#DEND"))
        .filter(Pattern.compile("^[^#].*:").asPredicate())
        .map(item -> item.split(":", 2))
        .collect(Collectors.toMap(parts->parts[0], parts->parts[1]));
}
// use the map
map.forEach((k,v)->System.out.println(k+" -> "+v));

dropWhile will drop all elements before the first matching element, skip(1) will skip the matching element, takeWhile effectively removes all elements after the first element matching the end criteria.

The next filter step using the pattern ^[^#].*: will skip all lines starting with # or not containing a :. The remaining steps are straight-forward. When specifying a limit of 2 to split, it will not search for subsequent :s after encountering the first :.

Under Java 8, extracting the part between the two matches can be implemented with a Scanner before the stream operation:

String part;
try(Scanner s = new Scanner(path)) {
    part = s.findWithinHorizon("(?<=\\R#DATA\\R)(.|\\R)*(?=\\R#DEND\\R)", 0);
}
Map<String,String> map = Pattern.compile("\\R").splitAsStream(part)
    .filter(Pattern.compile("^[^#].*:").asPredicate())
    .map(item -> item.split(":", 2))
    .collect(Collectors.toMap(parts->parts[0], parts->parts[1]));
// use the map
map.forEach((k,v)->System.out.println(k+" -> "+v));

Answer 2

If you see the lies between #DATA and #DEND contain ':' therefore I came up with the following solution -

    File file = new File("Input.txt");
    try {
        Map<String,String> map = Files.lines(file.toPath())
                                     .filter(list -> list.contains(":"))
                                     .map(item -> item.split(":"))
                                     .filter(arr -> arr.length > 1)
                                     .collect(Collectors.toMap(parts->parts[0], parts->parts[1]));
        System.out.println(map.values());
    } catch (IOException e) {
        e.printStackTrace();
    }

The above code first filters only the lines containing colon ':', then split these lines based on the colon, after that, we filter only the list having length greater than 1 because if you see the input.txt file carefully, you can find that "#ENTRIES:" contains colon but do not contain any character after that as others do. Once we get the required data we create the HashMap.

Answer 3

Following code pattern resolves your problem:

    List<String> lines = Files.readAllLines(Paths.get("Input.txt"));
    int from = lines.indexOf("#DATA") + 1;
    int to  = lines.indexOf("#DEND");
    Map<String, String> map = lines.stream()
            .skip(from)
            .limit(to - from)
            .map(s -> s.split(":"))
            .collect(Collectors.toMap(pair -> pair[0], pair -> pair[1]));