Lesen Sie den String Zeile für Zeile

Was ist der beste Weg, eine Zeichenfolge, die nicht zu lang ist, Zeile für Zeile zu lesen?

Ich weiß, dass Sie Folgendes tun können:

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

Eine andere Möglichkeit wäre, die Teilzeichenfolge auf dem Eol zu nehmen:

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

Irgendwelche anderen vielleicht einfacheren Möglichkeiten, es zu tun? Ich habe keine Probleme mit den oben genannten Ansätzen, bin nur daran interessiert zu wissen, ob jemand von Ihnen etwas kennt, das einfacher und effizienter aussieht?

Es gibt auch Scanner. Sie können es genauso verwenden wie die BufferedReader:

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

Ich denke, dass dies ein etwas saubererer Ansatz ist als die beiden vorgeschlagenen.

Sie können auch die verwenden split Methode von String:

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

Dadurch erhalten Sie alle Linien in einem handlichen Array.

Ich weiß nichts über die Leistung von Split. Es verwendet reguläre Ausdrücke.

Da mich besonders der Wirkungsgradwinkel interessierte, habe ich eine kleine Testklasse erstellt (unten). Ergebnis für 5.000.000 Zeilen:

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

Wie üblich können die genauen Zeiten variieren, aber das Verhältnis gilt, egal wie oft ich es ausgeführt habe.

Fazit: Die “einfacheren” und “effizienteren” Anforderungen des OP können nicht gleichzeitig erfüllt werden, die split Lösung (in beiden Inkarnationen) ist einfacher, aber die Reader Implementierung schlägt die anderen Hände nach unten.

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

Verwenden Apache Commons IOUtils Sie können dies gut über tun

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

Es macht nichts Cleveres, aber es ist schön und kompakt. Es wird auch mit Streams umgehen, und Sie können eine bekommen LineIterator auch, wenn Sie es vorziehen.

Lösung verwenden Java 8 Funktionen wie z Stream API und Method references

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

oder

public void someMethod(String myLongString) {

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

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

Seit Java 11 gibt es eine neue Methode String.lines:

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

Verwendungszweck:

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

Sie können auch verwenden:

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

Wenn das nicht funktioniert, versuchen Sie es mit einem Austausch \n mit \r\n.