重温IO流读写文件

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/nongminkouhao/article/details/84401279

前段时间写后台跑批每天生成一个增量文件，今天有空将IO读写文件重温一下，复制一个文本文件内容到另外一个文本文件中；

代码如下：使用了5种方式

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/**
 * ----------字符流-----------
 * Reader 接口
 * Writer 接口
 * 
 * FileReader
 * FileWriter	不调close不调flush写入失败，内容为空;调close不调flush可以写入成功，但安全起见（停电等情况）flush写上为好			
 * 
 * BufferedReader
 * BufferedWriter		不调close不调flush写入失败，内容为空;调close不调flush可以写入成功，但安全起见（停电等情况）flush写上为好
 * 
 * InputStreamReader  输入转换流  可以指定读取的编码
 * OutputStreamWriter 输出转换流  可以指定写的编码   	不调close不调flush写入失败，内容为空;调close不调flush可以写入成功，但安全起见（停电等情况）flush写上为好
 * -----------字节流---------
 * InputStream 	接口
 * OutputStream 接口
 * 
 * FileInputStream
 * FileOutputStream   这个不close不flush都可以写入成功
 * 
 * BufferedInputStream
 * BufferedOutputStream   不调close不调flush写入失败，内容为空;调close不调flush可以写入成功，但安全起见（停电等情况）flush写上为好
 * -------------------
 * 复制文本文件
 */
public class IOTest1 {
	public static void main(String[] args) {
		copyFile();
	}
	
	/**
	 * 复制文本文件
	 * 只有 FileWriter抛出IOException，其他都抛FileNotFoundExcepiton；read、close等方法都抛IOException
	 */
	public static void copyFile() {
		//普通字节流
		FileInputStream fileInputStream = null;
		FileOutputStream fileOutputStream = null;
		try{
			fileInputStream = new FileInputStream(new File("d:\\0.txt"));//FileInputStream抛FileNotFoundExcepiton
			fileOutputStream = new FileOutputStream(new File("d:\\1.txt"));//FileOutputStream抛FileNotFoundException
			
			byte[] dd = new byte[1024];
			int len = -1;
			while ((len=fileInputStream.read(dd))!=-1) {
				fileOutputStream.write(dd,0,len);
//				fileOutputStream.flush();//这里可以不要
			}
			
		}catch (FileNotFoundException e) {
		}catch (IOException e) {
		}finally {
			if(fileOutputStream!=null) {
				try {
					fileOutputStream.close();
				}catch (IOException e) {
				}
			}
			if(fileInputStream!=null) {
				try {
					fileInputStream.close();
				}catch (IOException e) {
				}
			}
		}
		
		//高效字节流
		BufferedInputStream bufferedInputStream = null;
		BufferedOutputStream bufferedOutputStream = null;
		try {
			bufferedInputStream = new BufferedInputStream(new FileInputStream("d:\\0.txt"));
			bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("d:\\2.txt"));
			
			byte[] dd = new byte[1024];
			int len = -1;
			while ((len=bufferedInputStream.read(dd))!=-1) {
				bufferedOutputStream.write(dd,0,len);
				bufferedOutputStream.flush();//调用close方法內部调用flush刷新，但是为了确保数据完整性，还是写上
			}
		} catch (FileNotFoundException e) {
			// TODO: handle exception
		} catch (IOException e) {
			// TODO: handle exception
		} finally {
			if(bufferedOutputStream!=null) {
				try {
					bufferedOutputStream.close();
				}catch (IOException e) {
				}
			}
			if(bufferedInputStream!=null) {
				try {
					bufferedInputStream.close();
				}catch (IOException e) {
				}
			}
		}
		
		//普通字符流
		FileReader fileReader = null;
		FileWriter fileWriter = null;
		try {
			fileReader = new FileReader("d:\\0.txt");
			fileWriter = new FileWriter("d:\\3.txt");
			
			char[] dd = new char[1024];
			int len = -1;
			while ((len=fileReader.read(dd))!=-1) {
				fileWriter.write(dd,0,len);
				fileWriter.flush();//调用close方法內部调用flush刷新，但是为了确保数据完整性，还是写上
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
		}finally {
			if(fileWriter!=null) {
				try {
					fileWriter.close();
				} catch (IOException e2) {
				}
			}
			
			if(fileReader!=null) {
				try {
					fileReader.close();
				} catch (IOException e2) {
				}
			}
		}
		
		//高效字符流
		BufferedReader bufferedReader = null;
		BufferedWriter bufferedWriter = null;
		try {
			bufferedReader = new BufferedReader(new FileReader("d:\\0.txt"));//FileReader抛出FileNotFoundException
			bufferedWriter = new BufferedWriter(new FileWriter("d:\\4.txt"));//FileWriter抛出IOException
			
			String readLine = null;
			while((readLine = bufferedReader.readLine())!=null) {
				bufferedWriter.write(readLine);
				bufferedWriter.newLine();//每写一行就需要换行
				bufferedWriter.flush();//调用close方法內部调用flush刷新，但是为了确保数据完整性，还是写上
			}
			
		} catch (FileNotFoundException e) {
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(bufferedWriter!=null) {
				try {
					bufferedWriter.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(bufferedReader!=null) {
				try {
					bufferedReader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		//转换流
		InputStreamReader inputStreamReader = null;
		OutputStreamWriter outputStreamWriter = null;
		try {
			inputStreamReader = new InputStreamReader(new FileInputStream("d:\\0.txt"));//FileInputStream抛FileNotFoundException
			outputStreamWriter = new OutputStreamWriter(new FileOutputStream("d:\\5.txt"));//FileOutputStream抛FileNotFoundException
			char[] dd = new char[1024];
			int len = -1;
			while ((len=inputStreamReader.read(dd))!=-1) {
				outputStreamWriter.write(dd,0,len);
				outputStreamWriter.flush();//调用close方法內部调用flush刷新，但是为了确保数据完整性，还是写上
			}
		} catch (FileNotFoundException e) {
			// TODO: handle exception
		} catch (IOException e) {
			// TODO: handle exception
		} finally {
			if(outputStreamWriter!=null) {
				try {
					outputStreamWriter.close();
				}catch (IOException e) {
				}
			}
			if(inputStreamReader!=null) {
				try {
					inputStreamReader.close();
				}catch (IOException e) {
				}
			}
		}
	}
}

代码中有详细注释，令有同学可能对flush和close有点混淆，可以看
关于java中输出流flush()方法
结束，希望对看到的朋友有所帮助