อ่านไฟล์ข้อความธรรมดาใน Java

ดูเหมือนว่ามีวิธีที่แตกต่างในการอ่านและเขียนข้อมูลของไฟล์ใน Java

ฉันต้องการอ่านข้อมูล ASCII จากไฟล์ อะไรคือวิธีที่เป็นไปได้และความแตกต่างของพวกเขา?

ASCII เป็นไฟล์ข้อความดังนั้นคุณจะใช้Readersสำหรับการอ่าน Java InputStreamsนอกจากนี้ยังสนับสนุนการอ่านจากแฟ้มไบนารีใช้ หากไฟล์ที่กำลังอ่านมีขนาดใหญ่มากคุณควรใช้ a BufferedReaderด้านบนของ a FileReaderเพื่อปรับปรุงประสิทธิภาพการอ่าน

อ่านบทความนี้เกี่ยวกับวิธีการใช้Reader

ฉันอยากจะแนะนำให้คุณดาวน์โหลดและอ่านหนังสือยอดเยี่ยม (ฟรี) เล่มนี้ชื่อว่าThinking In Java

ใน Java 7 :

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

(เอกสาร) หรือ

Files.readAllLines(...)

(เอกสาร)

ใน Java 8 :

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

(เอกสาร)

วิธีที่ฉันชอบอ่านไฟล์ขนาดเล็กคือใช้ BufferedReader และ StringBuilder มันง่ายมากและตรงประเด็น (แม้ว่าจะไม่มีประสิทธิภาพโดยเฉพาะ แต่ดีพอสำหรับกรณีส่วนใหญ่):

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

บางคนชี้ให้เห็นว่าหลังจาก Java 7 คุณควรใช้คุณสมบัติลองกับทรัพยากร (เช่นปิดอัตโนมัติ):

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

เมื่อฉันอ่านสตริงเช่นนี้ฉันมักจะต้องการจัดการสตริงบางอย่างต่อบรรทัดดังนั้นฉันจึงไปดำเนินการนี้

แม้ว่าถ้าฉันต้องการอ่านไฟล์ลงใน String จริง ๆ ฉันก็ใช้ Apache Commons IOกับเมธอด class IOUtils.toString () เสมอ คุณสามารถดูแหล่งที่มาที่นี่:

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

และง่ายยิ่งขึ้นด้วย Java 7:

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

วิธีที่ง่ายที่สุดคือการใช้Scannerคลาสใน Java และวัตถุ FileReader ตัวอย่างง่ายๆ:

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

Scanner มีหลายวิธีในการอ่านในสตริงตัวเลข ฯลฯ ... คุณสามารถค้นหาข้อมูลเพิ่มเติมได้จากหน้าเอกสาร Java

ตัวอย่างเช่นการอ่านเนื้อหาทั้งหมดลงในString:

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

นอกจากนี้หากคุณต้องการการเข้ารหัสที่เฉพาะเจาะจงคุณสามารถใช้สิ่งนี้แทนFileReader:

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

นี่เป็นวิธีง่ายๆ:

String content;

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

นี่เป็นอีกวิธีในการทำโดยไม่ต้องใช้ไลบรารีภายนอก:

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

ฉันต้องเปรียบเทียบวิธีต่างๆ ฉันจะแสดงความคิดเห็นเกี่ยวกับสิ่งที่ฉันค้นพบ แต่ในระยะสั้นวิธีที่เร็วที่สุดคือการใช้ BufferedInputStream แบบธรรมดาผ่าน FileInputStream หากต้องอ่านหลายไฟล์เธรดสามเธรดจะลดเวลาการดำเนินการทั้งหมดเป็นครึ่งหนึ่งโดยประมาณ แต่การเพิ่มเธรดเพิ่มเติมจะทำให้ประสิทธิภาพลดลงอย่างต่อเนื่องจนกว่าจะใช้เวลานานกว่าสามเธรดในการดำเนินการยี่สิบเธรด

สมมติฐานคือคุณต้องอ่านไฟล์และทำสิ่งที่มีความหมายกับเนื้อหา ในตัวอย่างที่นี่คือการอ่านบรรทัดจากบันทึกและนับรายการที่มีค่าที่เกินขีด จำกัด ที่แน่นอน ดังนั้นฉันจึงสันนิษฐานว่า Java 8 ซับเดียวFiles.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))ไม่ใช่ตัวเลือก

ฉันทดสอบกับ Java 1.8, Windows 7 และไดรฟ์ SSD และ HDD

ฉันเขียนการใช้งานหกแบบ:

rawParse : ใช้ BufferedInputStream ผ่าน FileInputStream แล้วตัดเส้นการอ่านแบบไบต์ต่อไบต์ วิธีนี้มีประสิทธิภาพสูงกว่าวิธีการเธรดเดี่ยวอื่น ๆ แต่อาจไม่สะดวกมากสำหรับไฟล์ที่ไม่ใช่ ASCII

lineReaderParse : ใช้ BufferedReader ผ่าน FileReader อ่านทีละบรรทัดแบ่งบรรทัดโดยการเรียก String.split () นี่คือประมาณ 20% ช้าลงว่า rawParse

lineReaderParseParallel : นี่เป็นเหมือนกับ lineReaderParse แต่ใช้หลายเธรด นี่คือตัวเลือกที่เร็วที่สุดโดยรวมในทุกกรณี

nioFilesParse : ใช้ java.nio.files.Files.lines ()

nioAsyncParse : ใช้ AsynchronousFileChannel พร้อมตัวจัดการความสมบูรณ์และเธรดพูล

nioMemoryMappedParse : ใช้ไฟล์ที่แม็พหน่วยความจำ นี่เป็นความคิดที่ดีจริงๆที่ให้เวลาดำเนินการอย่างน้อยสามครั้งนานกว่าการใช้งานอื่น ๆ

นี่เป็นเวลาเฉลี่ยสำหรับการอ่านไฟล์ 204 ไฟล์ละ 4 MB บนไดรฟ์ quad-core i7 และ SSD ไฟล์ถูกสร้างขึ้นทันทีเพื่อหลีกเลี่ยงการแคชดิสก์

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

ฉันพบความแตกต่างที่เล็กกว่าที่ฉันคาดไว้ระหว่างใช้ SSD หรือ HDD เป็น SSD เร็วขึ้นประมาณ 15% นี่อาจเป็นเพราะไฟล์ถูกสร้างขึ้นบน HDD ที่ไม่มีการจัดเรียงและพวกมันจะถูกอ่านตามลำดับดังนั้นไดร์ฟที่หมุนได้สามารถทำงานได้เกือบเหมือนกับ SSD

ฉันรู้สึกประหลาดใจกับการใช้งาน nioAsyncParse ที่มีประสิทธิภาพต่ำ อย่างใดอย่างหนึ่งฉันได้ดำเนินการบางอย่างในทางที่ผิดหรือการใช้งานแบบมัลติเธรดโดยใช้ NIO และตัวจัดการการดำเนินการเสร็จสิ้นการดำเนินการเดียวกัน (หรือแย่กว่า) กว่าการใช้งานแบบเธรดเดียวด้วย java.io API ยิ่งไปกว่านั้นการแยกวิเคราะห์แบบอะซิงโครนัสกับ CompletionHandler นั้นมีความยาวมากในบรรทัดของรหัสและใช้ในการดำเนินการอย่างถูกต้องมากกว่าการนำไปใช้โดยตรงในสตรีมเก่า

ตอนนี้การใช้งานหกครั้งตามด้วยคลาสที่บรรจุพวกมันทั้งหมดรวมถึงวิธีการหลัก () แบบ parametrizable ที่อนุญาตให้เล่นกับจำนวนไฟล์ขนาดไฟล์และระดับการทำงานพร้อมกัน โปรดทราบว่าขนาดของไฟล์จะแตกต่างกันไปบวกกับลบ 20% เพื่อหลีกเลี่ยงผลกระทบใด ๆ เนื่องจากไฟล์ทั้งหมดมีขนาดเท่ากันทุกประการ

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

การใช้งานเต็มรูปแบบของทุกกรณี

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

นี่คือวิธีการทำงานและทดสอบสามวิธี:

การใช้ 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);
        }
    }
}

การใช้ 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());
        }
    }
}

การใช้ 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);
        }
    }
}

อ่านไฟล์ทั้งหมดโดยไม่ต้องวนซ้ำโดยใช้Scannerคลาส

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

วิธีการภายในorg.apache.commons.io.FileUtilsอาจมีประโยชน์มากเช่น:

/**
 * 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)

คุณต้องการทำอะไรกับข้อความ ไฟล์เล็กพอที่จะใส่ในหน่วยความจำหรือไม่? ฉันจะพยายามหาวิธีที่ง่ายที่สุดในการจัดการไฟล์ตามความต้องการของคุณ ไลบรารี FileUtils จัดการได้ดีในเรื่องนี้

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

ฉันบันทึกเอกสาร15 วิธีในการอ่านไฟล์ใน Javaจากนั้นทดสอบความเร็วด้วยขนาดไฟล์ต่าง ๆ ตั้งแต่ 1 KB ถึง 1 GB และต่อไปนี้เป็นสามวิธียอดนิยมในการทำเช่นนี้:

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

   ผ่านการทดสอบการใช้งานใน Java 7, 8 และ 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()

   ผ่านการทดสอบการทำงานใน 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()

   สิ่งนี้ถูกทดสอบเพื่อให้ทำงานใน Java 8 และ 9 แต่จะไม่ทำงานใน Java 7 เนื่องจากข้อกำหนดการแสดงออกแลมบ์ดา

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

ด้านล่างเป็นหนึ่งซับของการทำใน Java 8 ทาง text.txtไฟล์สมมติว่าอยู่ในรูทของไดเร็กทอรีโปรเจ็กต์ของ Eclipse

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

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

นี่เป็นพื้นเดียวกันกับคำตอบของ Jesus Ramos ยกเว้นกับFileแทนFileReaderบวกซ้ำเพื่อก้าวผ่านเนื้อหาของไฟล์

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

... พ่น FileNotFoundException

คลาสสตรีมที่บัฟเฟอร์นั้นมีประสิทธิภาพมากกว่าในทางปฏิบัติดังนั้น NIO.2 API จึงมีวิธีที่จะส่งคืนคลาสสตรีมเหล่านี้โดยเฉพาะเพื่อสนับสนุนให้คุณใช้สตรีมบัฟเฟอร์ในแอปพลิเคชันของคุณเสมอ

นี่คือตัวอย่าง:

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...
}

คุณสามารถแทนที่รหัสนี้

BufferedReader reader = Files.newBufferedReader(path);

กับ

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

ผมขอแนะนำให้นี้บทความที่จะเรียนรู้การใช้งานหลักของ Java NIO และ IO

อาจไม่เร็วเท่ากับ I / O ที่บัฟเฟอร์ แต่ค่อนข้างสั้น:

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

\Zรูปแบบที่บอกScannerว่าตัวคั่นเป็น EOF

ฉันยังไม่เห็นมันกล่าวถึงในคำตอบอื่น ๆ แต่ถ้า "ดีที่สุด" หมายถึงความเร็วดังนั้น Java I / O (NIO) ใหม่อาจให้ผลการทดสอบที่เร็วที่สุด

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

วิธีที่ง่ายที่สุดในการอ่านข้อมูลจากไฟล์ใน Java คือการใช้คลาสFileเพื่ออ่านไฟล์และคลาสScannerเพื่ออ่านเนื้อหาของไฟล์

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: อย่าลืมนำเข้า java.util. *; สำหรับสแกนเนอร์ในการทำงาน

Guavaมอบหนึ่งซับในสำหรับสิ่งนี้:

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

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

นี่อาจไม่ใช่คำตอบที่แน่นอนสำหรับคำถาม เป็นอีกวิธีหนึ่งในการอ่านไฟล์ที่คุณไม่ได้ระบุพา ธ ไปยังไฟล์ของคุณในโค้ด Java อย่างชัดเจนและคุณอ่านมันเป็นอาร์กิวเมนต์บรรทัดคำสั่งแทน

ด้วยรหัสต่อไปนี้

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

เพียงไปข้างหน้าและเรียกใช้ด้วย:

java InputReader < input.txt

นี่จะอ่านเนื้อหาของinput.txtและพิมพ์ไปยังคอนโซลของคุณ

คุณยังสามารถทำของคุณ System.out.println()เขียนไปยังไฟล์เฉพาะผ่านบรรทัดคำสั่งดังต่อไปนี้:

java InputReader < input.txt > output.txt

นี้จะอ่านจากและเขียนไปยังinput.txtoutput.txt

คุณสามารถใช้ readAllLines และjoinวิธีการรับเนื้อหาไฟล์ทั้งหมดในหนึ่งบรรทัด:

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

มันใช้การเข้ารหัส UTF-8 โดยค่าเริ่มต้นซึ่งอ่านข้อมูล ASCII ได้อย่างถูกต้อง

นอกจากนี้คุณสามารถใช้ readAllBytes:

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

ผมคิดว่า readAllBytes ได้เร็วขึ้นและแม่นยำมากขึ้นเพราะมันไม่ได้เปลี่ยนสายใหม่ที่มีและยังมีสายใหม่อาจจะเป็น\n \r\nมันขึ้นอยู่กับความต้องการของคุณเป็นที่หนึ่งที่เหมาะสม

สำหรับแอปพลิเคชันบนเว็บ Maven ที่ใช้ JSF เพียงใช้ ClassLoader และResourcesโฟลเดอร์เพื่ออ่านไฟล์ใด ๆ

1. วางไฟล์ใด ๆ ที่คุณต้องการอ่านในโฟลเดอร์ทรัพยากร

2. ใส่ Apache Commons IO ลงใน POM ของคุณ:

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

3. ใช้รหัสด้านล่างเพื่ออ่าน (เช่นด้านล่างคือการอ่านในไฟล์. 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;

คุณสามารถทำเช่นเดียวกันสำหรับไฟล์ข้อความไฟล์. properties, XSD schemas เป็นต้น

Cactoosให้คุณเป็นหนึ่งซับประกาศ:

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

ใช้Java kissถ้าสิ่งนี้เกี่ยวกับความเรียบง่ายของโครงสร้าง:

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

 }

 }

เพียงใช้จาวา 8 สตรีม

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

วิธีการที่ใช้งานง่ายที่สุดถูกนำมาใช้ใน 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 มีความหรูหรานี้มาหลายสิบปีแล้ว! ☺

รหัสที่ฉันตั้งโปรแกรมนี้เร็วกว่าสำหรับไฟล์ที่มีขนาดใหญ่มาก:

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.

ชุดของบรรทัดด้านบนสามารถเขียนเป็น 1 บรรทัดเดียวดังนี้:

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

การเพิ่มไปยังตัวสร้างสตริง (หากไฟล์ของคุณมีขนาดใหญ่แนะนำให้ใช้ตัวสร้างสตริงอื่นใช้วัตถุสตริงปกติ)

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