Baca String baris demi baris

Mengingat string yang tidak terlalu panjang, apa cara terbaik untuk membacanya baris demi baris?

Saya tahu Anda dapat melakukannya:

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

Cara lain adalah dengan mengambil substring pada eol:

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

Adakah cara lain yang lebih sederhana untuk melakukannya? Saya tidak punya masalah dengan pendekatan di atas, hanya tertarik untuk mengetahui apakah ada di antara Anda tahu sesuatu yang mungkin terlihat lebih sederhana dan lebih efisien?

Anda juga dapat menggunakan splitmetode String:

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

Ini memberi Anda semua baris dalam array berguna.

Saya tidak tahu tentang kinerja split. Ini menggunakan ekspresi reguler.

Ada juga Scanner. Anda dapat menggunakannya seperti BufferedReader:

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

Saya pikir ini adalah pendekatan yang sedikit lebih bersih dari yang disarankan.

Karena saya sangat tertarik pada sudut efisiensi, saya membuat kelas uji kecil (di bawah). Hasil untuk 5.000.000 baris:

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

Seperti biasa, waktu yang tepat dapat bervariasi, tetapi rasio tetap berlaku namun sering saya menjalankannya.

Kesimpulan: persyaratan "lebih sederhana" dan "lebih efisien" dari OP tidak dapat dipenuhi secara bersamaan, splitsolusinya (dalam kedua inkarnasi) lebih sederhana, tetapi Readerimplementasinya mengalahkan yang lain.

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

Menggunakan Apache Commons IOUtils Anda dapat melakukannya dengan baik

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

Itu tidak melakukan sesuatu yang pintar, tetapi bagus dan kompak. Ini akan menangani stream juga, dan Anda bisa mendapatkan LineIteratorjuga jika Anda mau.

Solusi menggunakan Java 8fitur seperti Stream APIdanMethod references

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

atau

public void someMethod(String myLongString) {

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

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

Sejak Java 11, ada metode baru String.lines:

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

Pemakaian:

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

Anda dapat menggunakan api streaming dan StringReader yang dibungkus dengan BufferedReader yang mendapat baris () stream output di 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)
        );
    }
}

Memberi

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

Sama seperti di readLine BufferedReader, karakter baris baru itu sendiri tidak termasuk. Semua jenis pemisah baris baru didukung (dalam string yang sama genap).

Anda juga bisa menggunakan:

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

Jika itu tidak berhasil coba ganti \ndengan \r\n.

Atau gunakan percobaan baru dengan klausa sumber daya yang dikombinasikan dengan Pemindai:

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

Anda dapat mencoba ekspresi reguler berikut:

\r?\n

Kode:

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

Keluaran:

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

Pendekatan termudah dan paling universal adalah dengan hanya menggunakan regex Linebreak matcher \Ryang cocok Any Unicode linebreak sequence:

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

@lihat https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/regex/Pattern.html