Pertanyaan Membaca file teks biasa di Java


Tampaknya ada berbagai cara untuk membaca dan menulis data file di Java.

Saya ingin membaca data ASCII dari file. Apa cara yang mungkin dan perbedaan mereka?


796
2018-01-17 18:29


asal


Jawaban:


ASCII adalah file TEXT sehingga Anda akan menggunakannya Pembaca untuk dibaca. Java juga mendukung pembacaan dari file biner menggunakan InputStreams. Jika file yang sedang dibaca sangat besar maka Anda akan ingin menggunakan BufferedReader di atas a FileReader untuk meningkatkan kinerja baca.

Lewati artikel ini tentang cara menggunakan Reader

Saya juga merekomendasikan Anda untuk mengunduh dan membaca buku yang luar biasa (namun gratis) ini Berpikir Di Jawa

Di Java 7:

String baru (Files.readAllBytes (...)) atau Files.readAllLines (...)

Di Java 8:

File.lines (..). ForEach (...)


467
2018-01-17 18:31



Cara favorit saya untuk membaca file kecil adalah menggunakan BufferedReader dan StringBuilder. Ini sangat sederhana dan to the point (meskipun tidak terlalu efektif, tetapi cukup baik untuk sebagian besar kasus):

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();

    while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
    }
    String everything = sb.toString();
} finally {
    br.close();
}

Beberapa telah menunjukkan bahwa setelah Java 7 Anda harus menggunakan coba-dengan-sumber daya (yaitu fitur auto close):

try(BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();

    while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
    }
    String everything = sb.toString();
}

Ketika saya membaca string seperti ini, saya biasanya ingin melakukan beberapa penanganan string per baris, jadi saya pergi untuk implementasi ini.

Meskipun jika saya ingin benar-benar hanya membaca file menjadi String, saya selalu menggunakan Apache Commons IO dengan metode kelas IOUtils.toString (). Anda dapat melihat sumbernya di sini:

http://www.docjar.com/html/api/org/apache/commons/io/IOUtils.java.html

FileInputStream inputStream = new FileInputStream("foo.txt");
try {
    String everything = IOUtils.toString(inputStream);
} finally {
    inputStream.close();
}

Dan bahkan lebih sederhana dengan Java 7:

try(FileInputStream inputStream = new FileInputStream("foo.txt")) {     
    String everything = IOUtils.toString(inputStream);
    // do something with everything string
}

634
2018-01-17 18:42



Cara termudah adalah menggunakan Scanner kelas di Java dan objek FileReader. Contoh sederhana:

Scanner in = new Scanner(new FileReader("filename.txt"));

Scanner memiliki beberapa metode untuk membaca string, angka, dll ... Anda dapat mencari informasi lebih lanjut tentang ini di halaman dokumentasi Java.

Misalnya membaca seluruh konten menjadi String:

StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
    sb.append(in.next());
}
in.close();
outString = sb.toString();

Juga jika Anda membutuhkan pengkodean tertentu, Anda dapat menggunakan ini sebagai ganti FileReader:

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)

122
2018-01-17 18:35



Berikut ini solusi sederhana:

String content;

content = new String(Files.readAllBytes(Paths.get("sample.txt")));

59
2018-01-29 16:24



Berikut cara lain untuk melakukannya tanpa menggunakan pustaka eksternal:

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public String readFile(String filename)
{
    String content = null;
    File file = new File(filename); // For example, foo.txt
    FileReader reader = null;
    try {
        reader = new FileReader(file);
        char[] chars = new char[(int) file.length()];
        reader.read(chars);
        content = new String(chars);
        reader.close();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(reader != null){
            reader.close();
        }
    }
    return content;
}

54
2018-05-22 21:02



Metode dalam org.apache.commons.io.FileUtils mungkin juga sangat berguna, misalnya:

/**
 * Reads the contents of a file line by line to a List
 * of Strings using the default encoding for the VM.
 */
static List readLines(File file)

21
2018-01-17 18:46



Saya harus membandingkan berbagai cara. Saya akan mengomentari temuan saya, tetapi, singkatnya, cara tercepat adalah menggunakan BufferedInputStream lama biasa melalui FileInputStream. Jika banyak file harus dibaca, tiga utas akan mengurangi total waktu eksekusi menjadi kurang lebih separuh, tetapi menambahkan lebih banyak benang akan semakin menurunkan kinerja hingga membuatnya membutuhkan waktu tiga kali lebih lama untuk menyelesaikan dengan dua puluh untaian daripada hanya dengan satu utas.

Asumsinya adalah Anda harus membaca file dan melakukan sesuatu yang bermakna dengan isinya. Dalam contoh di sini adalah membaca garis dari log dan menghitung yang mengandung nilai yang melebihi batas tertentu. Jadi saya berasumsi bahwa satu-liner Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) bukan pilihan.

Saya menguji pada Java 1.8, Windows 7 dan kedua SSD dan HDD drive.

Saya menulis enam implementasi yang berbeda:

rawParse: Gunakan BufferedInputStream melalui FileInputStream dan kemudian memotong garis yang membaca byte demi byte. Ini mengungguli pendekatan single-thread lainnya, tetapi mungkin sangat tidak nyaman untuk file non-ASCII.

lineReaderParse: Gunakan BufferedReader di atas FileReader, baca baris demi baris, pisahkan baris dengan memanggil String.split (). Ini kira-kira 20% lebih lambat dari rawParse.

lineReaderParseParallel: Ini sama dengan lineReaderParse, tetapi menggunakan beberapa utas. Ini adalah opsi tercepat secara keseluruhan dalam semua kasus.

nioFilesParse: Gunakan java.nio.files.Files.lines ()

nioAsyncParse: Gunakan AsynchronousFileChannel dengan handler penyelesaian dan kolam thread.

nioMemoryMappedParse: Gunakan file yang dipetakan memori. Ini benar-benar ide yang buruk menghasilkan waktu eksekusi setidaknya tiga kali lebih lama daripada implementasi lainnya.

Ini adalah waktu rata-rata untuk membaca 204 file dari 4 MB masing-masing pada drive i7 dan SSD quad-core. File-file tersebut dibuat dengan cepat untuk menghindari disk cache.

rawParse                11.10 sec
lineReaderParse         13.86 sec
lineReaderParseParallel  6.00 sec
nioFilesParse           13.52 sec
nioAsyncParse           16.06 sec
nioMemoryMappedParse    37.68 sec

Saya menemukan perbedaan yang lebih kecil dari yang saya duga antara menjalankan SSD atau hard disk HDD dengan SSD sekitar 15% lebih cepat. Ini mungkin karena file dihasilkan pada HDD yang tidak terfragmentasi dan file-file tersebut dibaca secara berurutan, oleh karena itu drive yang berputar dapat melakukan hampir sebagai SSD.

Saya terkejut dengan rendahnya kinerja implementasi nioAsyncParse. Entah saya telah menerapkan sesuatu dengan cara yang salah atau implementasi multi-thread menggunakan NIO dan pengendali penyelesaian melakukan hal yang sama (atau bahkan lebih buruk) daripada implementasi single-thread dengan java.io API. Selain itu parse asinkron dengan CompletionHandler lebih panjang dalam baris kode dan sulit untuk diterapkan dengan benar daripada implementasi langsung pada aliran lama.

Sekarang enam implementasi diikuti oleh kelas yang berisi semuanya ditambah metode main (parametrizable) utama yang memungkinkan untuk bermain dengan jumlah file, ukuran file dan gelar concurrency. Perhatikan bahwa ukuran file bervariasi plus minus 20%. Ini untuk menghindari efek apa pun karena semua file memiliki ukuran yang persis sama.

rawParse

public void rawParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    overrunCount = 0;
    final int dl = (int) ';';
    StringBuffer lineBuffer = new StringBuffer(1024);
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileInputStream fin = new FileInputStream(fl);
        BufferedInputStream bin = new BufferedInputStream(fin);
        int character;
        while((character=bin.read())!=-1) {
            if (character==dl) {

                // Here is where something is done with each line
                doSomethingWithRawLine(lineBuffer.toString());
                lineBuffer.setLength(0);
            }
            else {
                lineBuffer.append((char) character);
            }
        }
        bin.close();
        fin.close();
    }
}

public final void doSomethingWithRawLine(String line) throws ParseException {
    // What to do for each line
    int fieldNumber = 0;
    final int len = line.length();
    StringBuffer fieldBuffer = new StringBuffer(256);
    for (int charPos=0; charPos<len; charPos++) {
        char c = line.charAt(charPos);
        if (c==DL0) {
            String fieldValue = fieldBuffer.toString();
            if (fieldValue.length()>0) {
                switch (fieldNumber) {
                    case 0:
                        Date dt = fmt.parse(fieldValue);
                        fieldNumber++;
                        break;
                    case 1:
                        double d = Double.parseDouble(fieldValue);
                        fieldNumber++;
                        break;
                    case 2:
                        int t = Integer.parseInt(fieldValue);
                        fieldNumber++;
                        break;
                    case 3:
                        if (fieldValue.equals("overrun"))
                            overrunCount++;
                        break;
                }
            }
            fieldBuffer.setLength(0);
        }
        else {
            fieldBuffer.append(c);
        }
    }
}

lineReaderParse

public void lineReaderParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    String line;
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileReader frd = new FileReader(fl);
        BufferedReader brd = new BufferedReader(frd);

        while ((line=brd.readLine())!=null)
            doSomethingWithLine(line);
        brd.close();
        frd.close();
    }
}

public final void doSomethingWithLine(String line) throws ParseException {
    // Example of what to do for each line
    String[] fields = line.split(";");
    Date dt = fmt.parse(fields[0]);
    double d = Double.parseDouble(fields[1]);
    int t = Integer.parseInt(fields[2]);
    if (fields[3].equals("overrun"))
        overrunCount++;
}

lineReaderParseParallel

public void lineReaderParseParallel(final String targetDir, final int numberOfFiles, final int degreeOfParalelism) throws IOException, ParseException, InterruptedException {
    Thread[] pool = new Thread[degreeOfParalelism];
    int batchSize = numberOfFiles / degreeOfParalelism;
    for (int b=0; b<degreeOfParalelism; b++) {
        pool[b] = new LineReaderParseThread(targetDir, b*batchSize, b*batchSize+b*batchSize);
        pool[b].start();
    }
    for (int b=0; b<degreeOfParalelism; b++)
        pool[b].join();
}

class LineReaderParseThread extends Thread {

    private String targetDir;
    private int fileFrom;
    private int fileTo;
    private DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private int overrunCounter = 0;

    public LineReaderParseThread(String targetDir, int fileFrom, int fileTo) {
        this.targetDir = targetDir;
        this.fileFrom = fileFrom;
        this.fileTo = fileTo;
    }

    private void doSomethingWithTheLine(String line) throws ParseException {
        String[] fields = line.split(DL);
        Date dt = fmt.parse(fields[0]);
        double d = Double.parseDouble(fields[1]);
        int t = Integer.parseInt(fields[2]);
        if (fields[3].equals("overrun"))
            overrunCounter++;
    }

    @Override
    public void run() {
        String line;
        for (int f=fileFrom; f<fileTo; f++) {
            File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
            try {
            FileReader frd = new FileReader(fl);
            BufferedReader brd = new BufferedReader(frd);
            while ((line=brd.readLine())!=null) {
                doSomethingWithTheLine(line);
            }
            brd.close();
            frd.close();
            } catch (IOException | ParseException ioe) { }
        }
    }
}

nioFilesParse

public void nioFilesParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    for (int f=0; f<numberOfFiles; f++) {
        Path ph = Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        Consumer<String> action = new LineConsumer();
        Stream<String> lines = Files.lines(ph);
        lines.forEach(action);
        lines.close();
    }
}


class LineConsumer implements Consumer<String> {

    @Override
    public void accept(String line) {

        // What to do for each line
        String[] fields = line.split(DL);
        if (fields.length>1) {
            try {
                Date dt = fmt.parse(fields[0]);
            }
            catch (ParseException e) {
            }
            double d = Double.parseDouble(fields[1]);
            int t = Integer.parseInt(fields[2]);
            if (fields[3].equals("overrun"))
                overrunCount++;
        }
    }
}

nioAsyncParse

public void nioAsyncParse(final String targetDir, final int numberOfFiles, final int numberOfThreads, final int bufferSize) throws IOException, ParseException, InterruptedException {
    ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(numberOfThreads);
    ConcurrentLinkedQueue<ByteBuffer> byteBuffers = new ConcurrentLinkedQueue<ByteBuffer>();

    for (int b=0; b<numberOfThreads; b++)
        byteBuffers.add(ByteBuffer.allocate(bufferSize));

    for (int f=0; f<numberOfFiles; f++) {
        consumerThreads.acquire();
        String fileName = targetDir+filenamePreffix+String.valueOf(f)+".txt";
        AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(fileName), EnumSet.of(StandardOpenOption.READ), pool);
        BufferConsumer consumer = new BufferConsumer(byteBuffers, fileName, bufferSize);
        channel.read(consumer.buffer(), 0l, channel, consumer);
    }
    consumerThreads.acquire(numberOfThreads);
}


class BufferConsumer implements CompletionHandler<Integer, AsynchronousFileChannel> {

        private ConcurrentLinkedQueue<ByteBuffer> buffers;
        private ByteBuffer bytes;
        private String file;
        private StringBuffer chars;
        private int limit;
        private long position;
        private DateFormat frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        public BufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers, String fileName, int bufferSize) {
            buffers = byteBuffers;
            bytes = buffers.poll();
            if (bytes==null)
                bytes = ByteBuffer.allocate(bufferSize);

            file = fileName;
            chars = new StringBuffer(bufferSize);
            frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            limit = bufferSize;
            position = 0l;
        }

        public ByteBuffer buffer() {
            return bytes;
        }

        @Override
        public synchronized void completed(Integer result, AsynchronousFileChannel channel) {

            if (result!=-1) {
                bytes.flip();
                final int len = bytes.limit();
                int i = 0;
                try {
                    for (i = 0; i < len; i++) {
                        byte by = bytes.get();
                        if (by=='\n') {
                            // ***
                            // The code used to process the line goes here
                            chars.setLength(0);
                        }
                        else {
                                chars.append((char) by);
                        }
                    }
                }
                catch (Exception x) {
                    System.out.println(
                        "Caught exception " + x.getClass().getName() + " " + x.getMessage() +
                        " i=" + String.valueOf(i) + ", limit=" + String.valueOf(len) +
                        ", position="+String.valueOf(position));
                }

                if (len==limit) {
                    bytes.clear();
                    position += len;
                    channel.read(bytes, position, channel, this);
                }
                else {
                    try {
                        channel.close();
                    }
                    catch (IOException e) {
                    }
                    consumerThreads.release();
                    bytes.clear();
                    buffers.add(bytes);
                }
            }
            else {
                try {
                    channel.close();
                }
                catch (IOException e) {
                }
                consumerThreads.release();
                bytes.clear();
                buffers.add(bytes);
            }
        }

        @Override
        public void failed(Throwable e, AsynchronousFileChannel channel) {
        }
};

PENERAPAN PENUH TERLENGKAP DARI SEMUA KASUS

https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java


21
2017-11-14 20:20



Berikut adalah tiga metode yang berhasil dan teruji:

Menggunakan BufferedReader

package io;
import java.io.*;
public class ReadFromFile2 {
    public static void main(String[] args)throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        BufferedReader br = new BufferedReader(new FileReader(file));
        String st;
        while((st=br.readLine()) != null){
            System.out.println(st);
        }
    }
}

Menggunakan Scanner

package io;

import java.io.File;
import java.util.Scanner;

public class ReadFromFileUsingScanner {
    public static void main(String[] args) throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        Scanner sc = new Scanner(file);
        while(sc.hasNextLine()){
            System.out.println(sc.nextLine());
        }
    }
}

Menggunakan FileReader

package io;
import java.io.*;
public class ReadingFromFile {

    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("C:\\Users\\pankaj\\Desktop\\test.java");
        int i;
        while ((i=fr.read()) != -1){
            System.out.print((char) i);
        }
    }
}

Baca seluruh file tanpa loop menggunakan Scanner kelas

package io;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ReadingEntireFileWithoutLoop {

    public static void main(String[] args) throws FileNotFoundException {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        Scanner sc = new Scanner(file);
        sc.useDelimiter("\\Z");
        System.out.println(sc.next());
    }
}

19
2018-01-10 18:52