Leggi la stringa riga per riga

Data una stringa non troppo lunga, qual è il modo migliore per leggerla riga per riga?

So che puoi fare:

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

Un altro modo sarebbe quello di prendere la sottostringa sull'eol:

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

Altri modi forse più semplici per farlo? Non ho problemi con gli approcci di cui sopra, sono solo interessato a sapere se qualcuno di voi conosce qualcosa che può sembrare più semplice ed efficiente?

Puoi anche usare il splitmetodo String:

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

Questo ti dà tutte le linee in un array utile.

Non conosco le prestazioni della divisione. Usa espressioni regolari.

C'è anche Scanner. Puoi usarlo proprio come BufferedReader:

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

Penso che questo sia un approccio un po 'più pulito di quelli suggeriti.

Dato che ero particolarmente interessato all'angolo di efficienza, ho creato una piccola classe di test (sotto). Risultato per 5.000.000 di righe:

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

Come al solito, i tempi esatti possono variare, ma il rapporto è vero, tuttavia spesso l'ho eseguito.

Conclusione: i requisiti "più semplici" e "più efficienti" del PO non possono essere soddisfatti simultaneamente, la splitsoluzione (in entrambe le incarnazioni) è più semplice, ma l' Readerimplementazione batte le altre a mani basse.

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 puoi farlo bene tramite

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

Non sta facendo nulla di intelligente, ma è bello e compatto. Gestirà anche i flussi e puoi ottenerne uno LineIteratorse preferisci.

Soluzione che utilizza Java 8funzionalità come Stream APIeMethod 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
}

Da Java 11, esiste un nuovo metodo 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);

Puoi usare lo stream api e uno StringReader racchiuso in un BufferedReader che ha ottenuto un output di un flusso di righe () in 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

Proprio come in Readered di BufferedReader, i nuovi caratteri non sono inclusi. Sono supportati tutti i tipi di separatori newline (anche nella stessa stringa).

Puoi anche usare:

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

Se il problema persiste, prova a sostituirlo \ncon \r\n.

Oppure usa la nuova clausola try with resources combinata con Scanner:

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

Puoi provare la seguente espressione regolare:

\r?\n

Codice:

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);
}

Produzione:

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

L'approccio più semplice e universale sarebbe usare semplicemente la regex Linebreak matcher \Rche corrisponde 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