Ler String linha por linha

Dada uma string que não é muito longa, qual é a melhor maneira de lê-la linha por linha?

Eu sei que você pode fazer:

BufferedReader reader = new BufferedReader(new StringReader(<string>));
reader.readLine();

Outra maneira seria pegar a substring no eol:

final String eol = System.getProperty("line.separator");
output = output.substring(output.indexOf(eol + 1));

Alguma outra maneira talvez mais simples de fazer isso? Não tenho problemas com as abordagens acima, apenas interessado em saber se algum de vocês sabe algo que pode parecer mais simples e mais eficiente?

Você também pode usar o splitmétodo String:

String[] lines = myString.split(System.getProperty("line.separator"));

Isso fornece todas as linhas em uma matriz prática.

Eu não sei sobre o desempenho da divisão. Ele usa expressões regulares.

Existe também Scanner. Você pode usá-lo exatamente como BufferedReader:

Scanner scanner = new Scanner(myString);
while (scanner.hasNextLine()) {
  String line = scanner.nextLine();
  // process the line
}
scanner.close();

Eu acho que essa é uma abordagem um pouco mais limpa que as duas sugeridas.

Como eu estava especialmente interessado no ângulo da eficiência, criei uma pequena classe de teste (abaixo). Resultado para 5.000.000 de linhas:

Comparing line breaking performance of different solutions
Testing 5000000 lines
Split (all): 14665 ms
Split (CR only): 3752 ms
Scanner: 10005
Reader: 2060

Como de costume, os horários exatos podem variar, mas a proporção é verdadeira, embora muitas vezes eu a execute.

Conclusão: os requisitos "mais simples" e "mais eficientes" do OP não podem ser satisfeitos simultaneamente, a splitsolução (em qualquer encarnação) é mais simples, mas a Readerimplementação supera as demais.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * Test class for splitting a string into lines at linebreaks
 */
public class LineBreakTest {
    /** Main method: pass in desired line count as first parameter (default = 10000). */
    public static void main(String[] args) {
        int lineCount = args.length == 0 ? 10000 : Integer.parseInt(args[0]);
        System.out.println("Comparing line breaking performance of different solutions");
        System.out.printf("Testing %d lines%n", lineCount);
        String text = createText(lineCount);
        testSplitAllPlatforms(text);
        testSplitWindowsOnly(text);
        testScanner(text);
        testReader(text);
    }

    private static void testSplitAllPlatforms(String text) {
        long start = System.currentTimeMillis();
        text.split("\n\r|\r");
        System.out.printf("Split (regexp): %d%n", System.currentTimeMillis() - start);
    }

    private static void testSplitWindowsOnly(String text) {
        long start = System.currentTimeMillis();
        text.split("\n");
        System.out.printf("Split (CR only): %d%n", System.currentTimeMillis() - start);
    }

    private static void testScanner(String text) {
        long start = System.currentTimeMillis();
        List<String> result = new ArrayList<>();
        try (Scanner scanner = new Scanner(text)) {
            while (scanner.hasNextLine()) {
                result.add(scanner.nextLine());
            }
        }
        System.out.printf("Scanner: %d%n", System.currentTimeMillis() - start);
    }

    private static void testReader(String text) {
        long start = System.currentTimeMillis();
        List<String> result = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new StringReader(text))) {
            String line = reader.readLine();
            while (line != null) {
                result.add(line);
                line = reader.readLine();
            }
        } catch (IOException exc) {
            // quit
        }
        System.out.printf("Reader: %d%n", System.currentTimeMillis() - start);
    }

    private static String createText(int lineCount) {
        StringBuilder result = new StringBuilder();
        StringBuilder lineBuilder = new StringBuilder();
        for (int i = 0; i < 20; i++) {
            lineBuilder.append("word ");
        }
        String line = lineBuilder.toString();
        for (int i = 0; i < lineCount; i++) {
            result.append(line);
            result.append("\n");
        }
        return result.toString();
    }
}

Usando o Apache Commons IOUtils, você pode fazer isso muito bem via

List<String> lines = IOUtils.readLines(new StringReader(string));

Não está fazendo nada inteligente, mas é agradável e compacto. Ele também lida com fluxos, e você também pode obter um, LineIteratorse preferir.

Solução usando Java 8recursos como Stream APIeMethod references

new BufferedReader(new StringReader(myString))
        .lines().forEach(System.out::println);

ou

public void someMethod(String myLongString) {

    new BufferedReader(new StringReader(myLongString))
            .lines().forEach(this::parseString);
}

private void parseString(String data) {
    //do something
}

Desde o Java 11, existe um novo método String.lines:

/**
 * Returns a stream of lines extracted from this string,
 * separated by line terminators.
 * ...
 */
public Stream<String> lines() { ... }

Uso:

"line1\nline2\nlines3"
    .lines()
    .forEach(System.out::println);

Você pode usar a API do fluxo e um StringReader envolto em um BufferedReader que obteve uma saída de fluxo lines () no java 8:

import java.util.stream.*;
import java.io.*;
class test {
    public static void main(String... a) {
        String s = "this is a \nmultiline\rstring\r\nusing different newline styles";

        new BufferedReader(new StringReader(s)).lines().forEach(
            (line) -> System.out.println("one line of the string: " + line)
        );
    }
}

Dá

one line of the string: this is a
one line of the string: multiline
one line of the string: string
one line of the string: using different newline styles

Assim como no readLine do BufferedReader, os próprios caracteres de nova linha não são incluídos. Todos os tipos de separadores de nova linha são suportados (na mesma sequência mesmo).

Você também pode usar:

String[] lines = someString.split("\n");

Se isso não funcionar, tente substituir \npor \r\n.

Ou use a nova cláusula try with resources combinada com o Scanner:

   try (Scanner scanner = new Scanner(value)) {
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            // process the line
        }
    }

Você pode tentar a seguinte expressão regular:

\r?\n

Código:

String input = "\nab\n\n    \n\ncd\nef\n\n\n\n\n";
String[] lines = input.split("\\r?\\n", -1);
int n = 1;
for(String line : lines) {
    System.out.printf("\tLine %02d \"%s\"%n", n++, line);
}

Resultado:

Line 01 ""
Line 02 "ab"
Line 03 ""
Line 04 "    "
Line 05 ""
Line 06 "cd"
Line 07 "ef"
Line 08 ""
Line 09 ""
Line 10 ""
Line 11 ""
Line 12 ""

A abordagem mais fácil e universal seria usar apenas o regex Linebreak matcher \Rque corresponde Any Unicode linebreak sequence:

Pattern NEWLINE = Pattern.compile("\\R")
String lines[] = NEWLINE.split(input)

@see https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/regex/Pattern.html