逐行读取字符串

给定一个不太长的字符串，逐行读取它的最佳方法是什么？

我知道你可以做：

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

另一种方法是在eol上获取子字符串：

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

还有其他更简单的方法吗？我对上述方法没有任何问题，只是想知道你们中是否有人知道一些看起来更简单，更有效的方法？

您还可以使用splitString方法：

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

这使您可以方便地将所有行排列在一起。

我不知道拆分的性能。它使用正则表达式。

也有Scanner。您可以像使用它一样BufferedReader：

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

我认为这比两个建议的方法都更清洁一些。

由于我对效率角度特别感兴趣，因此我创建了一个小测试类（如下）。5,000,000行结果：

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

像往常一样，确切的时间可能会有所不同，但是无论我运行多少次，该比率都成立。

结论：不能同时满足OP的“更简单”和“更高效”的要求，split解决方案（无论是哪种形式）都更简单，但Reader实现却击败了其他人。

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

使用Apache Commons IOUtils，您可以通过以下方式很好地完成此操作

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

它没有做任何聪明的事情，但是它很好而且紧凑。它也会处理流，LineIterator如果愿意，您也可以获取流。

使用Java 8诸如Stream API和的功能的解决方案Method references

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

要么

public void someMethod(String myLongString) {

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

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

从Java 11开始，有一个新方法String.lines：

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

用法：

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

您可以使用流api和包裹在BufferedReader中的StringReader来获取Java 8中的lines（）流输出：

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

给

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

就像在BufferedReader的readLine中一样，不包括换行符。支持各种换行符（甚至在同一字符串中）。

您还可以使用：

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

如果不起作用尝试更换\n用\r\n。

或将新的try with resources子句与Scanner结合使用：

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

您可以尝试以下正则表达式：

\r?\n

码：

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

输出：

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

最简单，最通用的方法是只使用Linebreak matcher \R符合Any Unicode linebreak sequence以下条件的正则表达式：

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

@see https://docs.oracle.com/zh-CN/java/javase/11/docs/api/java.base/java/util/regex/Pattern.html