Membaca file teks biasa di Java

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

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

ASCII adalah file TEKS sehingga Anda akan menggunakannya Readersuntuk membaca. Java juga mendukung pembacaan dari file biner menggunakan InputStreams. Jika file yang sedang dibaca sangat besar maka Anda ingin menggunakan BufferedReaderdi atas aFileReader untuk meningkatkan kinerja membaca.

Bacalah artikel ini tentang cara menggunakan aReader

Saya juga merekomendasikan Anda mengunduh dan membaca buku yang luar biasa (belum gratis) ini berjudul Thinking In Java

Di Jawa 7 :

new String(Files.readAllBytes(...))

(docs) atau

Files.readAllLines(...)

(docs)

Di Jawa 8 :

Files.lines(..).forEach(...)

(docs)

Cara favorit saya untuk membaca file kecil adalah dengan menggunakan BufferedReader dan StringBuilder. Ini sangat sederhana dan to the point (meskipun tidak terlalu efektif, tetapi cukup baik untuk kebanyakan 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 fitur coba-dengan-sumber daya (yaitu tutup otomatis):

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 penanganan string per baris, jadi saya pergi untuk implementasi ini.

Padahal jika saya ingin benar-benar hanya membaca file menjadi sebuah String, saya selalu menggunakan Apache Commons IO dengan metode IOUtils.toString () kelas. 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
}

Cara termudah adalah dengan menggunakan Scannerkelas di Java dan objek FileReader. Contoh sederhana:

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

Scanner memiliki beberapa metode untuk membaca dalam 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 memerlukan penyandian khusus, Anda dapat menggunakannya sebagai ganti FileReader:

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

Ini adalah solusi sederhana:

String content;

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

Berikut cara lain untuk melakukannya tanpa menggunakan perpustakaan 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;
}

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

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

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

Saya menulis enam implementasi yang berbeda:

rawParse : Gunakan BufferedInputStream melalui FileInputStream dan kemudian potong garis 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, pisah baris dengan memanggil String.split (). Ini kira-kira 20% lebih lambat dari rawParse itu.

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 penangan penyelesaian dan kumpulan utas.

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 masing-masing 4 MB pada drive quad-core i7 dan SSD. File-file dihasilkan dengan cepat untuk menghindari cache disk.

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 lebih kecil dari yang saya harapkan antara berjalan pada SSD atau drive HDD menjadi SSD sekitar 15% lebih cepat. Ini mungkin karena file-file tersebut dihasilkan pada HDD yang tidak terfragmentasi dan dibaca secara berurutan, oleh karena itu drive pemintalan dapat bekerja hampir seperti SSD.

Saya terkejut dengan kinerja implementasi nioAsyncParse yang rendah. Entah saya telah mengimplementasikan sesuatu dengan cara yang salah atau implementasi multi-utas menggunakan NIO dan penyelesaian penangan melakukan hal yang sama (atau bahkan lebih buruk) daripada implementasi satu-utas dengan java.io API. Selain itu parse asinkron dengan CompletionHandler jauh lebih panjang dalam garis kode dan sulit untuk diterapkan dengan benar daripada implementasi langsung pada aliran lama.

Sekarang enam implementasi diikuti oleh kelas yang berisi semuanya ditambah metode parametrizable main () yang memungkinkan untuk bermain dengan jumlah file, ukuran file dan derajat konkurensi. Perhatikan bahwa ukuran file bervariasi plus minus 20%. Ini untuk menghindari efek apa pun karena semua file berukuran 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) {
        }
};

IMPLEMENTASI RUNNABLE PENUH SEMUA KASUS

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

Berikut adalah tiga metode yang berfungsi dan diuji:

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 Scannerkelas

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

Metode-metode di dalamnya org.apache.commons.io.FileUtilsjuga 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)

Apa yang ingin Anda lakukan dengan teks? Apakah file cukup kecil untuk masuk ke dalam memori? Saya akan mencoba mencari cara paling sederhana untuk menangani file untuk kebutuhan Anda. Pustaka FileUtils sangat menangani untuk ini.

for(String line: FileUtils.readLines("my-text-file"))
    System.out.println(line);

Saya mendokumentasikan 15 cara untuk membaca file di Jawa dan kemudian mengujinya untuk kecepatan dengan berbagai ukuran file - dari 1 KB hingga 1 GB dan berikut adalah tiga cara teratas untuk melakukan ini:

1. java.nio.file.Files.readAllBytes()

   Diuji untuk bekerja di Java 7, 8, dan 9.

   import java.io.File;
   import java.io.IOException;
   import java.nio.file.Files;
   
   public class ReadFile_Files_ReadAllBytes {
     public static void main(String [] pArgs) throws IOException {
       String fileName = "c:\\temp\\sample-10KB.txt";
       File file = new File(fileName);
   
       byte [] fileBytes = Files.readAllBytes(file.toPath());
       char singleChar;
       for(byte b : fileBytes) {
         singleChar = (char) b;
         System.out.print(singleChar);
       }
     }
   }

2. java.io.BufferedReader.readLine()

   Diuji untuk bekerja di Java 7, 8, 9.

   import java.io.BufferedReader;
   import java.io.FileReader;
   import java.io.IOException;
   
   public class ReadFile_BufferedReader_ReadLine {
     public static void main(String [] args) throws IOException {
       String fileName = "c:\\temp\\sample-10KB.txt";
       FileReader fileReader = new FileReader(fileName);
   
       try (BufferedReader bufferedReader = new BufferedReader(fileReader)) {
         String line;
         while((line = bufferedReader.readLine()) != null) {
           System.out.println(line);
         }
       }
     }
   }

3. java.nio.file.Files.lines()

   Ini diuji untuk berfungsi di Java 8 dan 9 tetapi tidak akan berfungsi di Java 7 karena persyaratan ekspresi lambda.

   import java.io.File;
   import java.io.IOException;
   import java.nio.file.Files;
   import java.util.stream.Stream;
   
   public class ReadFile_Files_Lines {
     public static void main(String[] pArgs) throws IOException {
       String fileName = "c:\\temp\\sample-10KB.txt";
       File file = new File(fileName);
   
       try (Stream linesStream = Files.lines(file.toPath())) {
         linesStream.forEach(line -> {
           System.out.println(line);
         });
       }
     }
   }

Di bawah ini adalah satu-baris melakukannya dengan cara Java 8. Mengasumsikan text.txtfile berada di root direktori proyek Eclipse.

Files.lines(Paths.get("text.txt")).collect(Collectors.toList());

Menggunakan BufferedReader:

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

BufferedReader br;
try {
    br = new BufferedReader(new FileReader("/fileToRead.txt"));
    try {
        String x;
        while ( (x = br.readLine()) != null ) {
            // Printing out each line in the file
            System.out.println(x);
        }
    }
    catch (IOException e) {
        e.printStackTrace();
    }
}
catch (FileNotFoundException e) {
    System.out.println(e);
    e.printStackTrace();
}

Ini pada dasarnya sama persis dengan jawaban Jesus Ramos, kecuali dengan File, bukan FileReader plus iterasi untuk menelusuri isi file.

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

while (in.hasNext()) { // Iterates each line in the file
    String line = in.nextLine();
    // Do something with line
}

in.close(); // Don't forget to close resource leaks

... melempar FileNotFoundException

Kelas-kelas aliran buffered jauh lebih berkinerja dalam praktek, begitu banyak sehingga NIO.2 API mencakup metode yang secara khusus mengembalikan kelas-kelas aliran ini, sebagian untuk mendorong Anda selalu menggunakan aliran buffered dalam aplikasi Anda.

Berikut ini sebuah contoh:

Path path = Paths.get("/myfolder/myfile.ext");
try (BufferedReader reader = Files.newBufferedReader(path)) {
    // Read from the stream
    String currentLine = null;
    while ((currentLine = reader.readLine()) != null)
        //do your code here
} catch (IOException e) {
    // Handle file I/O exception...
}

Anda dapat mengganti kode ini

BufferedReader reader = Files.newBufferedReader(path);

dengan

BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));

Saya merekomendasikan artikel ini untuk mempelajari kegunaan utama Java NIO dan IO.

Mungkin tidak secepat dengan I / O buffer, tetapi cukup singkat:

    String content;
    try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
        content = scanner.next();
    }

The \Zpola menceritakan Scannerbahwa pembatas adalah EOF.

Saya belum melihatnya disebutkan dalam jawaban lain sejauh ini. Tetapi jika "Terbaik" berarti kecepatan, maka Java I / O (NIO) yang baru mungkin memberikan kinerja yang tercepat, tetapi tidak selalu yang termudah untuk diketahui oleh seseorang yang sedang belajar.

http://download.oracle.com/javase/tutorial/essential/io/file.html

Cara paling sederhana untuk membaca data dari file di Jawa adalah menggunakan kelas File untuk membaca file dan kelas Scanner untuk membaca konten file.

public static void main(String args[])throws Exception
{
   File f = new File("input.txt");
   takeInputIn2DArray(f);
}

public static void takeInputIn2DArray(File f) throws Exception
{
    Scanner s = new Scanner(f);
    int a[][] = new int[20][20];
    for(int i=0; i<20; i++)
    {
        for(int j=0; j<20; j++)
        {
            a[i][j] = s.nextInt();
        }
    }
}

PS: Jangan lupa mengimpor java.util. *; agar Pemindai berfungsi.

Guava menyediakan satu-liner untuk ini:

import com.google.common.base.Charsets;
import com.google.common.io.Files;

String contents = Files.toString(filePath, Charsets.UTF_8);

Ini mungkin bukan jawaban yang tepat untuk pertanyaan itu. Ini hanyalah cara lain untuk membaca file di mana Anda tidak secara eksplisit menentukan path ke file Anda dalam kode Java Anda dan sebaliknya, Anda membacanya sebagai argumen baris perintah.

Dengan kode berikut,

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class InputReader{

    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s="";
        while((s=br.readLine())!=null){
            System.out.println(s);
        }
    }
}

langsung saja jalankan dengan:

java InputReader < input.txt

Ini akan membaca konten input.txtdan mencetaknya ke konsol Anda.

Anda juga dapat membuat Anda System.out.println()menulis ke file tertentu melalui baris perintah sebagai berikut:

java InputReader < input.txt > output.txt

Ini akan membaca dari input.txtdan menulis ke output.txt.

Anda dapat menggunakan readAllLines dan joinmetode untuk mendapatkan seluruh konten file dalam satu baris:

String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));

Ini menggunakan pengkodean UTF-8 secara default, yang membaca data ASCII dengan benar.

Anda juga dapat menggunakan readAllBytes:

String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);

Saya pikir readAllBytes lebih cepat dan lebih tepat, karena itu tidak menggantikan baris baru \ndan juga baris baru \r\n. Tergantung pada kebutuhan Anda mana yang cocok.

Untuk aplikasi web Maven berbasis JSF, cukup gunakan ClassLoader dan Resourcesfolder untuk membaca file apa pun yang Anda inginkan:

1. Masukkan semua file yang ingin Anda baca di folder Resources.

2. Masukkan ketergantungan Apache Commons IO ke POM Anda:

   <dependency>
       <groupId>org.apache.commons</groupId>
       <artifactId>commons-io</artifactId>
       <version>1.3.2</version>
   </dependency>

3. Gunakan kode di bawah ini untuk membacanya (mis. Di bawah ini dibaca dalam file .json):

   String metadata = null;
   FileInputStream inputStream;
   try {
   
       ClassLoader loader = Thread.currentThread().getContextClassLoader();
       inputStream = (FileInputStream) loader
               .getResourceAsStream("/metadata.json");
       metadata = IOUtils.toString(inputStream);
       inputStream.close();
   }
   catch (FileNotFoundException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
   }
   catch (IOException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
   }
   return metadata;

Anda dapat melakukan hal yang sama untuk file teks, file properti, skema XSD , dll.

Cactoos memberi Anda satu kalimat deklaratif:

new TextOf(new File("a.txt")).asString();

Gunakan ciuman Jawa jika ini tentang kesederhanaan struktur:

import static kiss.API.*;

class App {
  void run() {
    String line;
    try (Close in = inOpen("file.dat")) {
      while ((line = readLine()) != null) {
        println(line);
      }
    }
  }
}

import java.util.stream.Stream;
import java.nio.file.*;
import java.io.*;

class ReadFile {

 public static void main(String[] args) {

    String filename = "Test.txt";

    try(Stream<String> stream = Files.lines(Paths.get(filename))) {

          stream.forEach(System.out:: println);

    } catch (IOException e) {

        e.printStackTrace();
    }

 }

 }

Cukup gunakan java 8 Stream.

try {
  File f = new File("filename.txt");
  Scanner r = new Scanner(f);  
  while (r.hasNextLine()) {
    String data = r.nextLine();
    JOptionPane.showMessageDialog(data);
  }
  r.close();
} catch (FileNotFoundException ex) {
  JOptionPane.showMessageDialog("Error occurred");
  ex.printStackTrace();
}

Metode paling intuitif diperkenalkan di Java 11 Files.readString

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String args[]) throws IOException {
        String content = Files.readString(Paths.get("D:\\sandbox\\mvn\\my-app\\my-app.iml"));
        System.out.print(content);
    }
}

PHP memiliki kemewahan ini sejak puluhan tahun yang lalu! ☺

Kode yang saya programkan ini jauh lebih cepat untuk file yang sangat besar:

public String readDoc(File f) {
    String text = "";
    int read, N = 1024 * 1024;
    char[] buffer = new char[N];

    try {
        FileReader fr = new FileReader(f);
        BufferedReader br = new BufferedReader(fr);

        while(true) {
            read = br.read(buffer, 0, N);
            text += new String(buffer, 0, read);

            if(read < N) {
                break;
            }
        }
    } catch(Exception ex) {
        ex.printStackTrace();
    }

    return text;
}

String fileName = 'yourFileFullNameWithPath';
File file = new File(fileName); // Creates a new file object for your file
FileReader fr = new FileReader(file);// Creates a Reader that you can use to read the contents of a file read your file
BufferedReader br = new BufferedReader(fr); //Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.

Kumpulan baris di atas dapat ditulis dalam 1 baris tunggal sebagai:

BufferedReader br = new BufferedReader(new FileReader("file.txt")); // Optional

Menambahkan ke pembuat string (Jika file Anda besar, disarankan untuk menggunakan pembuat string yang lain menggunakan objek String normal)

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