English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Seit Jahren beschäftige ich mich mit Java und arbeite an Projekten im Bereich Web, einige Grundklassen habe ich fast vergessen. Ich möchte oft wieder anfangen, aber aus verschiedenen Gründen kann ich es nicht so tun.
其实不是没有时间，只是有时候忙于总结，今得空，下定决心将丢失的都捡起来。
文件读写是在项目中经常遇到的工作，有些时候是因为维护，有些时候是新功能开发。我们的任务总是很重，工作节奏很快，快到我们不能停下脚步去总结。
文件读写有以下几种常用的方法
1、字节读写（InputStream/OutputStream）
2、字符读取（FileReader/FileWriter）
3、行读取（BufferedReader/BufferedWriter）
代码（以读取为例）：
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
/**
* <b>文件读取类</b><br />
* 1、按字节读取文件内容<br />
* 2、按字符读取文件内容<br />
* 3、按行读取文件内容<br />
* @author qin_xijuan
*
*/
public class FileOperate {
private static final String FILE_PATH = "d:/work/the List of Beautiful Music.txt";
/**
* 以字节为单位读取文件内容
* @param filePath：需要读取的文件路径
*/
public static void readFileBybyte(String filePath) {
File file = new File(filePath);
// InputStream: Diese abstrakte Klasse ist die Superklasse aller Klassen, die Byte-Eingabestrom repräsentieren.
InputStream ins = null ;
try{
// FileInputStream: Aus einer Datei im Dateisystem werden Eingabebits gewonnen.
ins = new FileInputStream(file);
int temp ;
// read(): den nächsten Byte aus dem Eingabestrom lesen.
while((temp = ins.read())!=-1){
System.out.write(temp);
}
}
catch(Exception e){
e.getStackTrace();
}
finally{
if (ins != null){
try{
ins.close();
}
catch(IOException e){
e.getStackTrace();
}
}
}
}
/**
* 以字符为单位读取文件内容
* @param filePath
*/
public static void readFileByCharacter(String filePath){
File file = new File(filePath);
// FileReader: ein bequemer Klasse zum Lesen von Zeichendateien.
FileReader reader = null;
try{
reader = new FileReader(file);
int temp ;
while((temp = reader.read()) != -1){
if (((char) temp) != '\r') {
System.out.print((char) temp);
}
}
}
catch(IOException e){
e.getStackTrace();
}
finally{
if (reader != null){
try {
reader.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 以行为单位读取文件内容
* @param filePath
*/
public static void readFileByLine(String filePath){
File file = new File(filePath);
// BufferedReader: Lesen von Text aus dem Zeicheneingabestrom, puffert die Zeichen, um effiziente Lesung von Zeichen, Arrays und Zeilen zu ermöglichen.
BufferedReader buf = null;
try{
// FileReader: ein bequemer Klasse zum Lesen von Zeichendateien.
buf = new BufferedReader(new FileReader(file));
// buf = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
String temp = null ;
while ((temp = buf.readLine()) != null ){
System.out.println(temp);
}
}
catch(Exception e){
e.getStackTrace();
}
finally{
if(buf != null){
try{
buf.close();
}
catch (IOException e) {
e.getStackTrace();
}
}
}
}
public static void main(String args[]) {
readFileBybyte(FILE_PATH);
readFileByCharacter(FILE_PATH);
readFileByLine(FILE_PATH);
}
}
//-----------------------------------------------------------------分割线-----------------------------------------------------------------------------
再经过两位同行的提点下，我对之前写的文件做了点修改，并通过读写一个1.2M的文本文件来测试各方法的性能。从多次测试结果来看，行读写却是是Java.nio更有效率。
经过修改之后的代码如下：
package com.waddell.basic;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
/**
* <b>文件读取类</b><br />
* 1、按字节读取文件内容<br />
* 2、按字符读取文件内容<br />
* 3、按行读取文件内容<br />
*
* @author qin_xijuan
*
*/
public class FileOperate {
private static final String FILE_PATH = "d:/work/jipinwodi.txt";
/**
* 以字节为单位读写文件内容
*
* @param filePath
* ：需要读取的文件路径
*/
public static void readFileBybyte(String filePath) {
File file = new File(filePath);
// InputStream: Diese abstrakte Klasse ist die Superklasse aller Klassen, die Byte-Eingabestrom repräsentieren.
InputStream ins = null;
OutputStream outs = null;
try {
// FileInputStream: Aus einer Datei im Dateisystem werden Eingabebits gewonnen.
ins = new FileInputStream(file);
outs = new FileOutputStream("d:/work/readFileByByte.txt");
int temp;
// read(): den nächsten Byte aus dem Eingabestrom lesen.
while ((temp = ins.read()) != -1) {
outs.write(temp);
}
}
catch (Exception e) {
e.getStackTrace();
}
finally {
if (ins != null && outs != null) {
try {
outs.close();
ins.close();
}
catch (IOException e) {
e.getStackTrace();
}
}
}
}
/**
* Lesen und Schreiben von Dateiinhaltenzeichenweise
*
* @param filePath
*/
public static void readFileByCharacter(String filePath) {
File file = new File(filePath);
// FileReader: ein bequemer Klasse zum Lesen von Zeichendateien.
FileReader reader = null;
FileWriter writer = null;
try {
reader = new FileReader(file);
writer = new FileWriter("d:/work/readFileByCharacter.txt");
int temp;
while ((temp = reader.read()) != -1) {
writer.write((char)temp);
}
}
catch (IOException e) {
e.getStackTrace();
}
finally {
if (reader != null && writer != null) {
try {
reader.close();
writer.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* Lesen und Schreiben von Dateiinhaltenzeilenweise
*
* @param filePath
*/
public static void readFileByLine(String filePath) {
File file = new File(filePath);
// BufferedReader: Lesen von Text aus dem Zeicheneingabestrom, puffert die Zeichen, um effiziente Lesung von Zeichen, Arrays und Zeilen zu ermöglichen.
BufferedReader bufReader = null;
BufferedWriter bufWriter = null;
try {
// FileReader: ein bequemer Klasse zum Lesen von Zeichendateien.
bufReader = new BufferedReader(new FileReader(file));
bufWriter = new BufferedWriter(new FileWriter("d:/work/readFileByLine.txt"));
// buf = new BufferedReader(new InputStreamReader(new
// new FileInputStream(file)));
String temp = null;
while ((temp = bufReader.readLine()) != null) {
bufWriter.write(temp+"\n");
}
}
catch (Exception e) {
e.getStackTrace();
}
finally {
if (bufReader != null && bufWriter != null) {
try {
bufReader.close();
bufWriter.close();
}
catch (IOException e) {
e.getStackTrace();
}
}
}
}
/**
* Verwenden Sie Java.nio ByteBuffer, um eine Datei in eine andere Datei zu schreiben.
*
* @param filePath
*/
public static void readFileByBybeBuffer(String filePath) {
FileInputStream in = null;
FileOutputStream out = null;
try {
// Die Eingangs- und Ausgangs-Streams der Quelldatei und Zieldatei werden erhalten.
in = new FileInputStream(filePath);
out = new FileOutputStream("d:\/work/readFileByBybeBuffer.txt");
// Die Eingangs- und Ausgangs-Kanäle werden erhalten.
FileChannel fcIn = in.getChannel();
FileChannel fcOut = out.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (true) {
// Die Methode clear setzt den Puffer zurück, sodass er Daten empfangen kann.
buffer.clear();
// Daten werden vom Eingangs-Kanal in den Puffer gelesen.
int r = fcIn.read(buffer);
if (r == -1) {
break;
}
// Die Methode flip ermöglicht es dem Puffer, neue gelesene Daten in einen anderen Kanal zu schreiben.
buffer.flip();
fcOut.write(buffer);
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (in != null && out != null) {
try {
in.close();
out.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static long getTime(){
return System.currentTimeMillis();
}
public static void main(String args[]) {
long time1 = getTime() ;
// readFileByByte(FILE_PATH);// 8734,8281,8000:7781,8047
// readFileByCharacter(FILE_PATH);// 734, 437, 437, 438, 422
// readFileByLine(FILE_PATH);// 110, 94, 94, 110, 93
readFileByBybeBuffer(FILE_PATH);
// 125, 78, 62, 78, 62
long time2 = getTime() ;
System.out.println(time2-time1);
}
}
In der main-Methode, nach dem Aufruf der verschiedenen Methoden, gibt es fünf Datenpaare, die sind:5mal Lesen/Schreiben der Datei getestet (in Millisekunden).
Über Java.nio siehe: https://de.oldtoolbag.com/article/131338.htm
Persönliche Tests:
public static void main(String args[]) {
long time1 = getTime() ;
// readFileByByte(FILE_PATH); //2338,2286
// readFileByCharacter(FILE_PATH);//160:162,158
// readFileByLine(FILE_PATH); //46,51,57
// readFileByBybeBuffer(FILE_PATH);//19,18,17
// readFileByBybeBuffer(FILE_PATH);//2048: 11,13
// readFileByBybeBuffer(FILE_PATH);//1024*100 100k:711k: 6,6
// readFileByBybeBuffer(FILE_PATH);//1024*100 100k:1422k: 7
// readFileByBybeBuffer(FILE_PATH);//1024*100 100k:9951k: 49,48
// readFileByBybeBuffer(FILE_PATH);//1024*1000 1M:711k: 7,7
// readFileByBybeBuffer(FILE_PATH);//1024*1000 1M:1422k: 7,8
// readFileByBybeBuffer(FILE_PATH);//1024*1000 1M:9951k: 48,49
// readFileByBybeBuffer(FILE_PATH);//1024*10000 10M:711k: 21,13,17
// readFileByBybeBuffer(FILE_PATH);//1024*10000 10M:1422k: 16,17,14,15
// readFileByBybeBuffer(FILE_PATH);//1024*10000 10M:9951k:64,60
long time2 = getTime() ;
System.out.println(time2-time1);
}
Zusammenfassung
Das ist der Abschnitt über Java-Datei-Read-Write-IO in diesem Artikel/NIO und Leistung - detaillierter Code und Zusammenfassung, hoffentlich hilfreich für alle. Interessierte Freunde können weitere Themen auf dieser Website durchlesen, und wenn es Unvollkommenheiten gibt, freuen wir uns über Kommentare. Vielen Dank für die Unterstützung der Freunde dieser Website!
Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet bezogen und gehört dem Urheberrechtsinhaber. Der Inhalt wurde von Internetnutzern selbstständig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht manuell bearbeitet. Sie übernimmt auch keine Haftung für rechtliche Fragen. Wenn Sie urheberrechtlich beanstandete Inhalte finden, freuen wir uns über eine E-Mail an: notice#oldtoolbag.com (bei der E-Mail senden Sie bitte # durch @ ersetzen, um zu melden und relevante Beweise bereitzustellen. Wenn die Inhalte nach Überprüfung als urheberrechtlich beanstandet werden, werden die fraglichen Inhalte sofort gelöscht.>