Tampaknya ada berbagai cara untuk membaca dan menulis data dari file di Jawa.
Saya ingin membaca data ASCII dari sebuah file. Apa cara yang mungkin dan perbedaan mereka?
Cara favorit saya untuk membaca sebuah file kecil adalah dengan menggunakan BufferedReader dan StringBuilder. Hal ini sangat sederhana dan to the point (meskipun tidak terlalu efektif, tapi 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 Jawa 7 anda harus menggunakan try-with-resources (yaitu auto close) fitur:
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 lagian, jadi aku pergi untuk implementasi ini.
Meskipun jika saya ingin benar-benar membaca sebuah file ke dalam sebuah String, saya selalu menggunakan Apache Commons IO dengan kelas IOUtils.toString() method. Anda dapat melihat sumber berikut:
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
}
ASCII adalah file TEKS jadi anda akan menggunakan Pembaca
untuk membaca. Java juga mendukung membaca dari file biner menggunakan InputStreams
. Jika file yang sedang di baca yang besar maka anda akan ingin menggunakan BufferedReader
di atas FileReader
untuk meningkatkan kinerja baca.
Pergi melalui artikel ini pada bagaimana menggunakan Reader
I'd juga merekomendasikan anda untuk men-download dan membaca ini indah (gratis) buku yang disebut Berpikir Di Jawa
Di Java 7:
new String(Files.readAllBytes(...))
(docs) atau
Files.readAllLines(...)
Di Jawa 8:
Files.lines(..).forEach(...)
Cara termudah adalah dengan menggunakan Scanner
kelas di Jawa dan FileReader objek. Contoh sederhana:
Scanner in = new Scanner(new FileReader("filename.txt"));
Scanner
memiliki beberapa metode untuk membaca string, angka, dll... Anda dapat melihat untuk informasi lebih lanjut tentang ini di Jawa halaman dokumentasi.
Misalnya membaca seluruh isi ke dalam 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 bukan FileReader
:
new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)
Berikut ini's 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;
}
Aku harus patokan cara yang berbeda. Saya akan mengomentari temuan saya namun, dalam waktu singkat, cara tercepat adalah dengan menggunakan plain old BufferedInputStream atas FileInputStream. Jika banyak file yang harus dibaca kemudian tiga benang akan mengurangi total waktu eksekusi untuk kira-kira setengah, tetapi menambahkan lebih banyak benang akan semakin menurunkan kinerja sehingga memakan waktu tiga kali lebih lama untuk menyelesaikan dengan dua puluh benang dari hanya dengan satu benang.
Asumsi ini adalah bahwa anda harus membaca sebuah file dan melakukan sesuatu yang berarti dengan isinya. Dalam contoh di sini adalah membaca baris dari log dan menghitung orang-orang yang mengandung nilai-nilai yang melebihi batas tertentu. Jadi saya mengasumsikan bahwa satu-liner Jawa 8 File.garis(Jalan.mendapatkan("/path/ke/file.txt")).peta(garis -> line.split(";"))
adalah bukan pilihan.
Aku diuji di Jawa 1.8, Windows 7 dan kedua SSD dan HDD drive.
Saya menulis enam implementasi yang berbeda:
rawParse: Gunakan BufferedInputStream atas FileInputStream dan kemudian memotong garis membaca byte dengan byte. Ini mengungguli yang lain single-thread pendekatan, tetapi mungkin akan sangat nyaman untuk non-ASCII file.
lineReaderParse: Menggunakan BufferedReader atas FileReader, membaca garis dengan garis, garis pemisah dengan memanggil String.split(). Ini adalah approximatedly 20% lebih lambat yang rawParse.
lineReaderParseParallel: Ini adalah sama seperti lineReaderParse, tetapi menggunakan beberapa benang. Ini adalah pilihan tercepat secara keseluruhan dalam semua kasus.
nioFilesParse: Menggunakan java.nio.file.File.garis()
nioAsyncParse: Menggunakan AsynchronousFileChannel dengan penyelesaian handler dan benang kolam renang.
nioMemoryMappedParse: Menggunakan memory-mapped file. Ini adalah benar-benar ide yang buruk menghasilkan waktu eksekusi setidaknya tiga kali lebih lama dari yang lain implementasi.
Ini adalah waktu rata-rata untuk membaca 204 file 4 MB masing-masing pada sebuah quad-core i7 dan SSD drive. File yang dihasilkan dengan cepat untuk menghindari disk caching.
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 harapkan antara berjalan pada SSD atau HDD drive menjadi SSD sekitar 15% lebih cepat. Ini mungkin karena file yang dihasilkan tidak pecah HDD dan mereka baca secara berurutan, oleh karena itu berputar drive dapat melakukan hampir seperti SSD.
Saya terkejut dengan kinerja rendah dari nioAsyncParse implementasi. Baik saya telah menerapkan sesuatu dengan cara yang salah atau multi-thread implementasi menggunakan NIO dan penyelesaian handler melakukan hal yang sama (atau bahkan lebih buruk) dari sebuah single-thread implementasi dengan jawa.io API. Selain itu asynchronous mengurai dengan CompletionHandler lebih banyak lagi di baris kode dan rumit untuk menerapkan dengan benar daripada lurus implementasi di sungai.
Sekarang enam implementasi diikuti oleh kelas yang mengandung mereka semua ditambah parametrizable main() metode yang memungkinkan untuk bermain dengan jumlah file, ukuran file, dan concurrency derajat. Perhatikan bahwa ukuran file yang bervariasi plus minus 20%. Hal ini untuk menghindari efek apapun karena semua file yang dari ukuran yang sama persis.
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) {
}
};
PENUH RUNNABLE IMPLEMENTASI DARI SEMUA KASUS
https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java
Berikut ini adalah tiga bekerja dan diuji metode:
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
kelaspackage 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 dalam org.apache.commons.io.FileUtils
juga dapat menjadi 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? Adalah file yang cukup kecil untuk masuk ke dalam memori? Saya akan mencoba untuk menemukan cara paling sederhana untuk menangani file untuk kebutuhan anda. Yang FileUtils perpustakaan sangat pegangan untuk ini.
for(String line: FileUtils.readLines("my-text-file"))
System.out.println(line);
Saya didokumentasikan 15 cara untuk membaca file di Jawa dan kemudian menguji mereka untuk kecepatan dengan berbagai ukuran file - dari 1 KB untuk 1 GB dan berikut ini adalah tiga cara untuk melakukan ini:
jawa.nio.file.File.readAllBytes()
Diuji untuk bekerja di Java 7, 8, dan 9.
import java.io.File; import java.io.IOException; import java.nio.file.File;
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 = File.readAllBytes(file.toPath()); char singleChar; for(byte b : fileBytes) { singleChar = (char) b; Sistem.keluar.cetak(singleChar); } } }
jawa.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);
mencoba (BufferedReader bufferedReader = new BufferedReader(fileReader)) { String line; while((line = bufferedReader.readLine()) != null) { Sistem.keluar.println(garis); } } } }
jawa.nio.file.File.garis()
Ini telah diuji untuk bekerja di pulau Jawa 8 dan 9, tetapi tidak't bekerja di Java 7 karena ekspresi lambda kebutuhan.
import java.io.File; import java.io.IOException; import java.nio.file.File; 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);
mencoba (Stream linesStream = File.baris(file.toPath())) { linesStream.forEach(line -> { Sistem.keluar.println(garis); }); } } }
Ini pada dasarnya adalah persis sama seperti Yesus Ramos' jawaban, kecuali dengan File bukan FileReader plus iterasi untuk langkah melalui isi dari file tersebut.
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
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();
}
Mungkin tidak secepat dengan buffered I/O, tapi cukup singkat:
String content;
try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
content = scanner.next();
}
The \Z
pola menceritakan Scanner
yang delimiter adalah EOF.
Buffer stream kelas yang jauh lebih performant dalam prakteknya, begitu banyak sehingga NIO.2 API meliputi metode-metode yang secara khusus kembali ini aliran kelas, di bagian untuk mendorong anda untuk selalu menggunakan buffered aliran 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 ini artikel ini untuk mempelajari kegunaan utama dari Java NIO dan IO.
Cara yang paling sederhana untuk membaca data dari file di Jawa adalah membuat penggunaan File kelas untuk membaca file dan Scanner kelas untuk membaca isi 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: Don't lupa untuk mengimpor java.util.*; untuk Scanner untuk bekerja.
Saya don't melihat itu disebutkan namun dalam jawaban yang lain sejauh ini. Tapi jika "Terbaik" berarti kecepatan, kemudian baru Java I/O (NIO) mungkin memberikan tercepat dalm, tapi tidak selalu yang paling mudah untuk mengetahui seseorang belajar.
http://download.oracle.com/javase/tutorial/essential/io/file.html
Anda dapat menggunakan readAllLines dan join
metode untuk mendapatkan seluruh isi file dalam satu baris:
String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));
Menggunakan encoding UTF-8 secara default, yang berbunyi ASCII data 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 tidak ganti baris baru \n
dan juga baris baru dapat \r\n
. Hal ini tergantung pada kebutuhan anda mana yang cocok.
Ini mungkin tidak menjadi jawaban yang tepat untuk pertanyaan itu. It's hanya cara lain untuk membaca file 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);
}
}
}
hanya pergi ke depan dan menjalankan dengan:
java InputReader < input.txt
Ini akan membaca isi input.txt
dan mencetaknya ke konsol anda.
Anda juga dapat membuat anda Sistem.keluar.println()
untuk menulis ke sebuah file tertentu melalui baris perintah sebagai berikut:
java InputReader < input.txt > output.txt
Ini akan membaca dari input.txt
dan menulis output.txt
.