Leer cadena línea por línea

Dada una cadena que no es demasiado larga, ¿cuál es la mejor manera de leerla línea por línea?

Sé que puedes hacer:

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

Otra forma sería tomar la subcadena en el eol:

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

¿Alguna otra forma quizás más simple de hacerlo? No tengo problemas con los enfoques anteriores, solo estoy interesado en saber si alguno de ustedes sabe algo que pueda parecer más simple y más eficiente.

También puedes usar el splitmétodo de String:

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

Esto le da todas las líneas en una práctica matriz.

No sé sobre el rendimiento de la división. Utiliza expresiones regulares.

También existe Scanner. Puedes usarlo como BufferedReader:

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

Creo que este es un enfoque un poco más limpio que los dos sugeridos.

Como estaba especialmente interesado en el ángulo de eficiencia, creé una pequeña clase de prueba (a continuación). Resultado para 5,000,000 líneas:

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 costumbre, los tiempos exactos pueden variar, pero la relación es cierta, sin embargo, a menudo lo he ejecutado.

Conclusión: los requisitos "más simples" y "más eficientes" del OP no pueden satisfacerse simultáneamente, la splitsolución (en cualquier encarnación) es más simple, pero la Readerimplementación supera a las demás.

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 Apache Commons IOUtils puede hacerlo bien a través de

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

No está haciendo nada inteligente, pero es agradable y compacto. También manejará transmisiones, y puede obtener una LineIteratortambién si lo prefiere.

Solución utilizando Java 8características como Stream APIyMethod references

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

o

public void someMethod(String myLongString) {

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

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

Desde Java 11, hay un nuevo 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);

Puede usar la API de transmisión y un StringReader envuelto en un BufferedReader que obtuvo una salida de transmisión de líneas () en 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)
        );
    }
}

Da

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

Al igual que en la línea de lectura de BufferedReader, los caracteres de nueva línea no están incluidos. Se admiten todo tipo de separadores de nueva línea (incluso en la misma cadena).

También puedes usar:

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

Si eso no funciona, intente reemplazar \ncon \r\n.

O utilice la nueva cláusula try with resources combinada con Scanner:

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

Puede probar la siguiente expresión 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);
}

Salida:

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 ""

El enfoque más fácil y más universal sería usar la expresión regular Linebreak matcher \Rque coincida con Any Unicode linebreak sequence:

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

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