English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
干Java这么久，一直在做WEB相关的项目，一些基础类差不多都已经忘记。经常想得捡起，但总是因为一些原因，不能如愿。
其实不是没有时间，只是有些时候疲于总结，今得空，下定决心将丢掉的都给捡起来。
文件读写是一个在项目中经常遇到的工作，有些时候是因为维护，有些时候是新功能开发。我们的任务总是很重，工作节奏很快，快到我们不能停下脚步去总结。
文件读写有以下几种常用的方法
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>Classe di lettura dei file</b><br />
* 1, Leggi il contenuto del file per byte<br />
* 2, Leggi il contenuto del file per carattere<br />
* 3, Leggi il contenuto del file per riga<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: Questa classe astratta è il superclasse di tutte le classi che rappresentano i flussi di input di byte.
InputStream ins = null ;
try{
// FileInputStream: Ottieni i byte di input da un file nel sistema di file.
ins = new FileInputStream(file);
int temp ;
// read(): Leggi il byte successivo dal flusso di input.
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();
}
}
}
}
/**
* Legge il contenuto del file per carattere
* @param filePath
*/
public static void readFileByCharacter(String filePath){
File file = new File(filePath);
// FileReader:用来读取字符文件的便捷类。
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();
}
}
}
}
/**
* Legge il contenuto del file per riga
* @param filePath
*/
public static void readFileByLine(String filePath){
File file = new File(filePath);
// BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
BufferedReader buf = null;
try{
// FileReader:用来读取字符文件的便捷类。
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);
}
}
//-----------------------------------------------------------------linea di separazione//-----------------------------------------------------------------------------
Dopo essere stato consigliato da due colleghi, ho apportato alcune modifiche al file che avevo scritto in precedenza e ho testato le prestazioni di vari metodi leggendo e scrivendo un file di testo di 1.2M. Dai risultati di più test, è emerso che la lettura e scrittura a riga è più efficiente con Java.nio.
Il codice modificato dopo è il seguente:}}
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>Classe di lettura dei file</b><br />
* 1, Leggi il contenuto del file per byte<br />
* 2, Leggi il contenuto del file per carattere<br />
* 3, Leggi il contenuto del file per riga<br />
*
* @author qin_xijuan
*
*/
public class FileOperate {
private static final String FILE_PATH = "d:/work/jipinwodi.txt";
/**
* Leggi e scrivi il contenuto del file in unità di byte
*
* @param filePath
* : Percorso del file da leggere
*/
public static void readFileBybyte(String filePath) {
File file = new File(filePath);
// InputStream: Questa classe astratta è il superclasse di tutte le classi che rappresentano i flussi di input di byte.
InputStream ins = null;
OutputStream outs = null;
try {
// FileInputStream: Ottieni i byte di input da un file nel sistema di file.
ins = new FileInputStream(file);
outs = new FileOutputStream("d:/work/readFileByByte.txt");
int temp;
// read(): Leggi il byte successivo dal flusso di input.
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();
}
}
}
}
/**
* 以字符为单位读写文件内容
*
* @param filePath
*/
public static void readFileByCharacter(String filePath) {
File file = new File(filePath);
// FileReader:用来读取字符文件的便捷类。
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();
}
}
}
}
/**
* 以行为单位读写文件内容
*
* @param filePath
*/
public static void readFileByLine(String filePath) {
File file = new File(filePath);
// BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
BufferedReader bufReader = null;
BufferedWriter bufWriter = null;
try {
// FileReader:用来读取字符文件的便捷类。
bufReader = new BufferedReader(new FileReader(file));
bufWriter = new BufferedWriter(new FileWriter("d:/work/readFileByLine.txt"));
// buf = new BufferedReader(new InputStreamReader(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();
}
}
}
}
/**
* usa ByteBuffer di Java.nio per copiare un file in un altro file
*
* @param filePath
*/
public static void readFileByBybeBuffer(String filePath) {
FileInputStream in = null;
FileOutputStream out = null;
try {
// ottiene gli stream di input/output dei file di origine e destinazione
in = new FileInputStream(filePath);
out = new FileOutputStream("d:/work/readFileByBybeBuffer.txt");
// ottiene i canali di input/output
FileChannel fcIn = in.getChannel();
FileChannel fcOut = out.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (true) {
// il metodo clear riimposta il buffer per accettare nuovi dati di input
buffer.clear();
// legge i dati dal canale di input nel buffer
int r = fcIn.read(buffer);
if (r == -1) {
break;
}
// flip metodo rende il buffer disponibile per scrivere i nuovi dati in un altro canale
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);
}
}
Nel metodo main, dopo aver chiamato tutti i metodi, ci sono cinque gruppi di dati, che sono i miei cinque test di lettura e scrittura dei file in millisecondi.
Per Java.nio, fare riferimento a: https://it.oldtoolbag.com/article/131338.htm
personale test:
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);
}
Sommario
Questo è tutto il contenuto dettagliato del codice e della sommario relativi alla lettura e scrittura di file IO/NIO di Java e alla comparazione delle prestazioni, spero possa essere utile a tutti. Chi è interessato può continuare a consultare altre sezioni correlate di questo sito, e se ci sono difetti, è benvenuto a lasciare un messaggio. Grazie per il supporto dei amici di questo sito!
Dichiarazione: il contenuto di questo articolo è stato tratto da Internet, il diritto d'autore è di proprietà del rispettivo proprietario, il contenuto è stato contribuito e caricato volontariamente dagli utenti di Internet, questo sito non possiede il diritto di proprietà, non è stato editato manualmente e non assume alcuna responsabilità legale pertinente. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare, fornendo prove pertinenti. Una volta verificata, questo sito eliminerà immediatamente il contenuto sospetto di violazione del copyright.