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 me interesa saber si alguno de ustedes sabe algo que pueda parecer más simple y eficiente.

También hay Scanner. Puedes usarlo como el 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.

También puede utilizar el split método de cadena:

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

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

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

Como estaba especialmente interesado en el ángulo de la eficiencia, creé una pequeña clase de prueba (abajo). 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 proporción se mantiene independientemente de la frecuencia con la que la haya ejecutado.

Conclusión: los requisitos “más simples” y “más eficientes” del OP no pueden satisfacerse simultáneamente, el split solución (en cualquier encarnación) es más simple, pero el Reader la implementació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 Puedes hacerlo muy 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á flujos, y puede obtener un LineIterator también si lo prefieres.

Solución usando Java 8 características tales como Stream API y Method 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);

También puedes usar:

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

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