Java文件读写IO/NIO及性能比较详细代码及总结

2023-09-18 21:34:05 56

干Java这么久，一直在做WEB相关的项目，一些基础类差不多都已经忘记。经常想得捡起，但总是因为一些原因，不能如愿。

其实不是没有时间，只是有些时候疲于总结，今得空，下定决心将丢掉的都给捡起来。

文件读写是一个在项目中经常遇到的工作，有些时候是因为维护，有些时候是新功能开发。我们的任务总是很重，工作节奏很快，快到我们不能停下脚步去总结。

文件读写有以下几种常用的方法

1、字节读写（InputStream/OutputStream）

2、字符读取（FileReader/FileWriter）

3、行读取（BufferedReader/BufferedWriter）

代码（以读取为例）：

importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.InputStream;
/**
*文件读取类

*1、按字节读取文件内容

*2、按字符读取文件内容

*3、按行读取文件内容

*@authorqin_xijuan
*
*/
publicclassFileOperate{
	privatestaticfinalStringFILE_PATH="d:/work/theListofBeautifulMusic.txt";
	/**
*以字节为单位读取文件内容
*@paramfilePath：需要读取的文件路径
*/
	publicstaticvoidreadFileBybyte(StringfilePath){
		Filefile=newFile(filePath);
		//InputStream:此抽象类是表示字节输入流的所有类的超类。
		InputStreamins=null;
		try{
			//FileInputStream:从文件系统中的某个文件中获得输入字节。
			ins=newFileInputStream(file);
			inttemp;
			//read():从输入流中读取数据的下一个字节。
			while((temp=ins.read())!=-1){
				System.out.write(temp);
			}
		}
		catch(Exceptione){
			e.getStackTrace();
		}
		finally{
			if(ins!=null){
				try{
					ins.close();
				}
				catch(IOExceptione){
					e.getStackTrace();
				}
			}
		}
	}
	/**
*以字符为单位读取文件内容
*@paramfilePath
*/
	publicstaticvoidreadFileByCharacter(StringfilePath){
		Filefile=newFile(filePath);
		//FileReader:用来读取字符文件的便捷类。
		FileReaderreader=null;
		try{
			reader=newFileReader(file);
			inttemp;
			while((temp=reader.read())!=-1){
				if(((char)temp)!='\r'){
					System.out.print((char)temp);
				}
			}
		}
		catch(IOExceptione){
			e.getStackTrace();
		}
		finally{
			if(reader!=null){
				try{
					reader.close();
				}
				catch(IOExceptione){
					e.printStackTrace();
				}
			}
		}
	}
	/**
*以行为单位读取文件内容
*@paramfilePath
*/
	publicstaticvoidreadFileByLine(StringfilePath){
		Filefile=newFile(filePath);
		//BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
		BufferedReaderbuf=null;
		try{
			//FileReader:用来读取字符文件的便捷类。
			buf=newBufferedReader(newFileReader(file));
			//buf=newBufferedReader(newInputStreamReader(newFileInputStream(file)));
			Stringtemp=null;
			while((temp=buf.readLine())!=null){
				System.out.println(temp);
			}
		}
		catch(Exceptione){
			e.getStackTrace();
		}
		finally{
			if(buf!=null){
				try{
					buf.close();
				}
				catch(IOExceptione){
					e.getStackTrace();
				}
			}
		}
	}
	publicstaticvoidmain(Stringargs[]){
		readFileBybyte(FILE_PATH);
		readFileByCharacter(FILE_PATH);
		readFileByLine(FILE_PATH);
	}
}

//-----------------------------------------------------------------分割线-----------------------------------------------------------------------------

再经过两位同行的提点下，我对之前写的文件做了点修改，并通过读写一个1.2M的文本文件来测试各方法的性能。从多次测试结果来看，行读写却是是Java.nio更有效率。

经过修改之后的代码如下：

packagecom.waddell.basic;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.FileReader;
importjava.io.FileWriter;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.nio.ByteBuffer;
importjava.nio.channels.FileChannel;
/**
*文件读取类

*1、按字节读取文件内容

*2、按字符读取文件内容

*3、按行读取文件内容

*
*@authorqin_xijuan
*
*/
publicclassFileOperate{
	privatestaticfinalStringFILE_PATH="d:/work/jipinwodi.txt";
	/**
*以字节为单位读写文件内容
*
*@paramfilePath
*：需要读取的文件路径
*/
	publicstaticvoidreadFileBybyte(StringfilePath){
		Filefile=newFile(filePath);
		//InputStream:此抽象类是表示字节输入流的所有类的超类。
		InputStreamins=null;
		OutputStreamouts=null;
		try{
			//FileInputStream:从文件系统中的某个文件中获得输入字节。
			ins=newFileInputStream(file);
			outs=newFileOutputStream("d:/work/readFileByByte.txt");
			inttemp;
			//read():从输入流中读取数据的下一个字节。
			while((temp=ins.read())!=-1){
				outs.write(temp);
			}
		}
		catch(Exceptione){
			e.getStackTrace();
		}
		finally{
			if(ins!=null&&outs!=null){
				try{
					outs.close();
					ins.close();
				}
				catch(IOExceptione){
					e.getStackTrace();
				}
			}
		}
	}
	/**
*以字符为单位读写文件内容
*
*@paramfilePath
*/
	publicstaticvoidreadFileByCharacter(StringfilePath){
		Filefile=newFile(filePath);
		//FileReader:用来读取字符文件的便捷类。
		FileReaderreader=null;
		FileWriterwriter=null;
		try{
			reader=newFileReader(file);
			writer=newFileWriter("d:/work/readFileByCharacter.txt");
			inttemp;
			while((temp=reader.read())!=-1){
				writer.write((char)temp);
			}
		}
		catch(IOExceptione){
			e.getStackTrace();
		}
		finally{
			if(reader!=null&&writer!=null){
				try{
					reader.close();
					writer.close();
				}
				catch(IOExceptione){
					e.printStackTrace();
				}
			}
		}
	}
	/**
*以行为单位读写文件内容
*
*@paramfilePath
*/
	publicstaticvoidreadFileByLine(StringfilePath){
		Filefile=newFile(filePath);
		//BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
		BufferedReaderbufReader=null;
		BufferedWriterbufWriter=null;
		try{
			//FileReader:用来读取字符文件的便捷类。
			bufReader=newBufferedReader(newFileReader(file));
			bufWriter=newBufferedWriter(newFileWriter("d:/work/readFileByLine.txt"));
			//buf=newBufferedReader(newInputStreamReader(new
			//FileInputStream(file)));
			Stringtemp=null;
			while((temp=bufReader.readLine())!=null){
				bufWriter.write(temp+"\n");
			}
		}
		catch(Exceptione){
			e.getStackTrace();
		}
		finally{
			if(bufReader!=null&&bufWriter!=null){
				try{
					bufReader.close();
					bufWriter.close();
				}
				catch(IOExceptione){
					e.getStackTrace();
				}
			}
		}
	}
	/**
*使用Java.nioByteBuffer字节将一个文件输出至另一文件
*
*@paramfilePath
*/
	publicstaticvoidreadFileByBybeBuffer(StringfilePath){
		FileInputStreamin=null;
		FileOutputStreamout=null;
		try{
			//获取源文件和目标文件的输入输出流
			in=newFileInputStream(filePath);
			out=newFileOutputStream("d:/work/readFileByBybeBuffer.txt");
			//获取输入输出通道
			FileChannelfcIn=in.getChannel();
			FileChannelfcOut=out.getChannel();
			ByteBufferbuffer=ByteBuffer.allocate(1024);
			while(true){
				//clear方法重设缓冲区，使它可以接受读入的数据
				buffer.clear();
				//从输入通道中将数据读到缓冲区
				intr=fcIn.read(buffer);
				if(r==-1){
					break;
				}
				//flip方法让缓冲区可以将新读入的数据写入另一个通道
				buffer.flip();
				fcOut.write(buffer);
			}
		}
		catch(Exceptione){
			e.printStackTrace();
		}
		finally{
			if(in!=null&&out!=null){
				try{
					in.close();
					out.close();
				}
				catch(IOExceptione){
					e.printStackTrace();
				}
			}
		}
	}
	publicstaticlonggetTime(){
		returnSystem.currentTimeMillis();
	}
	publicstaticvoidmain(Stringargs[]){
		longtime1=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
		longtime2=getTime();
		System.out.println(time2-time1);
	}
}

在main方法中，调用各方法之后，有五组数据，分辨是我5次读写文件测试出来的时间（毫秒）。

关于Java.nio请参考：https://www.nhooo.com/article/131338.htm

个人测试：

publicstaticvoidmain(Stringargs[]){
	longtime1=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*100100k,711k:6,6
	//readFileByBybeBuffer(FILE_PATH);//1024*100100k,1422k:7
	//readFileByBybeBuffer(FILE_PATH);//1024*100100k,9951k:49,48
	//readFileByBybeBuffer(FILE_PATH);//1024*10001M,711k:7,7
	//readFileByBybeBuffer(FILE_PATH);//1024*10001M,1422k:7,8
	//readFileByBybeBuffer(FILE_PATH);//1024*10001M,9951k:48,49
	//readFileByBybeBuffer(FILE_PATH);//1024*1000010M,711k:21,13,17
	//readFileByBybeBuffer(FILE_PATH);//1024*1000010M,1422k:16,17,14,15
	//readFileByBybeBuffer(FILE_PATH);//1024*1000010M,9951k:64,60
	longtime2=getTime();
	System.out.println(time2-time1);
}

总结

以上就是本文关于Java文件读写IO/NIO及性能比较详细代码及总结的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！

Java文件读写IO/NIO及性能比较详细代码及总结

热门推荐

随机推荐