Summary

Add an instance method to java.lang.String that returns a stream of the lines of the contents of a multi-line string.

Problem

With the introduction of JEP 326 Raw String Literals, it is expected that developers will make routine use of multi-line strings in their applications. To facilitate processing of multi-line strings it will be common for developers to break those strings down into collections of lines.

The existing techniques for production of collections of lines vary depending on the application goals. If the developer wants to use streams and functional coding style, then the techniques available can be cumbersome.

Ex 1.
    Stream<String> lines = List.of(string.split(`\n|\r\n|\r`)).stream();

Ex 2. (more recently)
    Stream<String> lines = List.of(string.split(`\R`)).stream();

Ex 3.
    Stream<String> lines = Pattern.compile(`\R`).splitAsStream​(string);

Ex 4.
    Stream<String> lines = new BufferedReader​(new StringReader​(string)).lines();

Beside being cumbersome, examples 1 & 2 require additional memory for an intermediate array and all line substrings up front.

Solution

Introduce a String instance method that uses a specialized Spliterator to lazily provide lines from the source string.

    Stream<String> lines = string.lines();

This method simplifies the developer code, significantly reduces memory requirements and is an order of magnitude faster that any previously subscribed code pattern.

Ex.
    String trimmedLines = string.lines()
                                .map(String::trim)
                                .collect(joining("\n"));

Specification

    /**
     * Returns a stream of substrings extracted from this string
     * partitioned by line terminators.
     * <p>
     * Line terminators recognized are line feed
     * {@code "\n"} ({@code U+000A}),
     * carriage return
     * {@code "\r"} ({@code U+000D})
     * and a carriage return followed immediately by a line feed
     * {@code "\r\n"} ({@code U+000D U+000A}).
     * <p>
     * The stream returned by this method contains each line of
     * this string that is terminated by a line terminator except that
     * the last line can either be terminated by a line terminator or the 
     * end of the string.
     * The lines in the stream are in the order in which
     * they occur in this string and do not include the line terminators
     * partitioning the lines.
     *
     * @implNote This method provides better performance than
     *           split("\R") by supplying elements lazily and
     *           by faster search of new line terminators.
     *
     * @return  the stream of strings extracted from this string
     *          partitioned by line terminators
     *
     * @since 11
     */
    public Stream<String> lines() {