Lire la chaîne ligne par ligne

Étant donné une chaîne qui n'est pas trop longue, quelle est la meilleure façon de la lire ligne par ligne?

Je sais que tu peux faire:

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

Une autre façon serait de prendre la sous-chaîne sur l'eol:

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

Y a-t-il d'autres façons peut-être plus simples de le faire? Je n'ai aucun problème avec les approches ci-dessus, juste intéressé de savoir si l'un d'entre vous sait quelque chose qui peut paraître plus simple et plus efficace?

Vous pouvez également utiliser la splitméthode de String:

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

Cela vous donne toutes les lignes dans un tableau pratique.

Je ne connais pas les performances de Split. Il utilise des expressions régulières.

Il y a aussi Scanner. Vous pouvez l'utiliser comme le BufferedReader:

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

Je pense que c'est une approche un peu plus propre que les deux suggérées.

Comme j'étais particulièrement intéressé par l'angle d'efficacité, j'ai créé une petite classe de test (ci-dessous). Résultat pour 5.000.000 de lignes:

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

Comme d'habitude, les heures exactes peuvent varier, mais le ratio est vrai quelle que soit la fréquence à laquelle je l'ai exécuté.

Conclusion: les exigences "plus simples" et "plus efficaces" de l'OP ne peuvent pas être satisfaites simultanément, la splitsolution (dans les deux cas) est plus simple, mais la Readermise en œuvre bat les autres haut la main.

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

En utilisant Apache Commons IOUtils, vous pouvez le faire facilement via

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

Il ne fait rien d'intelligent, mais c'est joli et compact. Il gérera également les flux, et vous pouvez en obtenir un LineIteratoraussi si vous préférez.

Solution utilisant des Java 8fonctionnalités telles que Stream APIetMethod 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
}

Depuis Java 11, il existe une nouvelle méthode String.lines:

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

Usage:

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

Vous pouvez utiliser l'API de flux et un StringReader enveloppés dans un BufferedReader qui a obtenu une sortie de flux lines () dans 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)
        );
    }
}

Donne

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

Tout comme dans readLine de BufferedReader, les caractères de nouvelle ligne eux-mêmes ne sont pas inclus. Tous les types de séparateurs de nouvelle ligne sont pris en charge (même dans la même chaîne).

Vous pouvez aussi utiliser:

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

Si cela ne fonctionne pas, essayez de remplacer \npar \r\n.

Ou utilisez la clause new try with resources combinée à Scanner:

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

Vous pouvez essayer l'expression régulière suivante:

\r?\n

Code:

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

Production:

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'approche la plus simple et la plus universelle serait d'utiliser simplement l'expression régulière Linebreak matcher \Rqui correspond à 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