IO流框架总结

普通IO（BIO）/ NIO

字节流

字节输入流

--InputStream
	int available() 返回流中可用的字节数
	void close() 
	abstract  int read() 读取一个字节
	int read(byte[] b) 读取一个字节数组
	int read(byte[] b, int off, int len) 读取字节数组的一部分 
	long skip(long n) 跳过多n个字节读取 
		
		//子类
		--FileInputStream
  			FileInputStream(File file) 
			/*通过打开一个到实际文件的连接来创建一个 FileInputStream，
			该文件通过文件系统中的 File 对象 file 指定。*/ 
			FileInputStream(FileDescriptor fdObj) 
			/*通过使用文件描述符 fdObj 创建一个 FileInputStream，
			该文件描述符表示到文件系统中某个实际文件的现有连接。*/ 
			FileInputStream(String name) 
			/*通过打开一个到实际文件的连接来创建一个 FileInputStream，
			该文件通过文件系统中的路径名 name 指定。 */
						          
		-- BufferedInputStream
			//能够提高读写效率

字节输出流

--OutputStream
	void close() 关闭此输出流并释放与此流有关的所有系统资源。 
	void flush() 将数据从内存中刷新到文件系统中
	void write(byte[] b) 写一个字节数组
	void write(byte[] b, int off, int len) 写一个字节数组的一部分
	abstract  void write(int b) 写一个字节
				
		//子类			
		--FileOutputStream
			FileOutputStream(File file) 
			//创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 
			FileOutputStream(File file, boolean append) 
			//创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 
			FileOutputStream(FileDescriptor fdObj) 
			/*创建一个向指定文件描述符处写入数据的输出文件流，
			该文件描述符表示一个到文件系统中的某个实际文件的现有连接。*/
			FileOutputStream(String name) 
			创建一个向具有指定名称的文件中写入数据的输出文件流。 
			FileOutputStream(String name, boolean append) 
			创建一个向具有指定 name 的文件中写入数据的输出文件流。 
		
		--BufferedOutputStream
			//能够提高读写效率

字符流

字符输入流

Reader
...
转换流: InputStreamReader
1.处理编码
2.将字节流转化成字符流
FileReader是InputStreamReader子类
高效缓冲字符输入流 BufferedReader
readLine() 读取一行

字符输出流

Writer
...
转换流: OutputStreamWriter
1.处理编码
2.将字节流转化成字符流
FileWriter是OutputStreamWriter子类
高效缓冲字符输出流 BufferedWriter
newLine() 写一个换行符

九种方式拷贝文件

文件拷贝的方式和原理:
1.FileInputStream/FileOutputStream一次性读取一个字节
2.FileInputStream/FileOutputStream一次性读取一个字节数组
3.BufferedInputStream/BufferedOutputStream一次性读取一个字节
4.BufferedInputStream/BufferedOutputStream一次性读取一个字节数组
5.FileReader/FileWriter一次性读取一个字符
6.FileReader/FileWriter一次性读取一个字符数组
7.BufferedReader/BufferedWriter一次性读取一个字符
8.BufferedReader/BufferedWriter一次性读取一个字符数组
9.BufferedReader/BufferedWriter一次性读取一行

代码如下：

package com.sxt.homework;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
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;
import java.io.Reader;
import java.io.Writer;

/**
 * 	使用至少9种方式拷贝文件 
 * 	文件拷贝的方式和原理:
 * 		1.FileInputStream/FileOutputStream一次性读取一个字节
 * 		2.FileInputStream/FileOutputStream一次性读取一个字节数组
 * 		3.BufferedInputStream/BufferedOutputStream一次性读取一个字节
 * 		4.BufferedInputStream/BufferedOutputStream一次性读取一个字节数组
 * 		5.FileReader/FileWriter一次性读取一个字符
 * 		6.FileReader/FileWriter一次性读取一个字符数组
 * 		7.BufferedReader/BufferedWriter一次性读取一个字符
 * 		8.BufferedReader/BufferedWriter一次性读取一个字符数组
 * 		9.BufferedReader/BufferedWriter一次性读取一行
 * @author berger
 *
 */
public class Homework01 {
	public static void main(String[] args) {
		
	}
	
	//1.FileInputStream/FileOutputStream一次性读取一个字节
	public static void copy1(String srcFileName, String descFileName) {
		try (FileInputStream f1 = new FileInputStream(srcFileName);
				FileOutputStream f2 = new FileOutputStream(descFileName)){
			int by = 0;
			while ((by = f1.read()) != -1) {
				f2.write(by);
				f2.flush();
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}
	
	//2.FileInputStream/FileOutputStream一次性读取一个字节数组
	public static void copy2(String srcFileName, String descFileName) {
		try (FileInputStream f1 = new FileInputStream(srcFileName);
				FileOutputStream f2 = new FileOutputStream(descFileName)){
			byte [] by = new byte[8192];
			int len = 0;
			while ((len = f1.read(by)) != -1) {
				for (byte b : by) {
					f2.write(b);
					f2.flush();
				}
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}
	
	//3.BufferedInputStream/BufferedOutputStream一次性读取一个字节
	public static void copy3(String srcFileName, String descFileName) {
		try (BufferedInputStream f1 = new BufferedInputStream(new FileInputStream(srcFileName));
				BufferedOutputStream f2 = new BufferedOutputStream(new FileOutputStream(descFileName))){
			int by = 0;
			while ((by = f1.read()) != -1) {
				f2.write(by);
				f2.flush();
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}
	
	//4.BufferedInputStream/BufferedOutputStream一次性读取一个字节数组
	public static void copy4(String srcFileName, String descFileName) {
		try (BufferedInputStream f1 = new BufferedInputStream(new FileInputStream(srcFileName));
				BufferedOutputStream f2 = new BufferedOutputStream(new FileOutputStream(descFileName))){
			byte [] by = new byte[8192];
			int len = 0;
			while ((len = f1.read(by)) != -1) {
				for (byte b : by) {
					f2.write(b);
					f2.flush();
				}
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}
	
	//5.FileReader/FileWriter一次性读取一个字符
	public static void copy5(String srcFileName, String descFileName) {
		try (FileReader f1 = new FileReader(srcFileName);
				FileWriter f2 = new FileWriter(descFileName)){
			int by = 0;
			while ((by = f1.read()) != -1) {
				f2.write(by);
				f2.flush();
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}
	
	//6.FileReader/FileWriter一次性读取一个字符数组
	public static void copy6(String srcFileName, String descFileName) {
		try (FileReader f1 = new FileReader(srcFileName);
				FileWriter f2 = new FileWriter(descFileName)){
			char [] by = new char[8192];
			int len = 0;
			while ((len = f1.read(by)) != -1) {
				for (char c : by) {
					f2.write(c);
					f2.flush();
				}
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}
	
	//7.BufferedReader/BufferedWriter一次性读取一个字符
	public static void copy7(String srcFileName,String descFileName) {
		try(Reader f1 = new BufferedReader(new FileReader(srcFileName));
				Writer f2 = new BufferedWriter(new FileWriter(descFileName))){
			int by = 0;
			while ((by = f1.read()) != -1) {
				f2.write(by);
				f2.flush();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch (IOException e) {
			e.printStackTrace();
		} 
	}
	
	//8.BufferedReader/BufferedWriter一次性读取一个字符数组
	public static void copy8(String srcFileName, String descFileName) {
		try (BufferedReader f1 = new BufferedReader(new FileReader(srcFileName));
				BufferedWriter f2 = new BufferedWriter(new FileWriter(descFileName))){
			char [] ch = new char[8192];
			int len = 0;
			while ((len = f1.read(ch)) != -1) {
				for (char c : ch) {
					f2.write(c);
					f2.flush();
				}
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	//9.BufferedReader/BufferedWriter一次性读取一行
	public static void copy9(String srcFileName, String descFileName) {
		try (BufferedReader f1 = new BufferedReader(new FileReader(srcFileName));
				BufferedWriter f2 = new BufferedWriter(new FileWriter(descFileName))){
			while ((f1.readLine()) != null) {
				f2.write(f1.readLine());
				f2.newLine();
				f2.flush();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}