IO流的分类及常用案例

IO流的分类：
1、根据流的数据对象来分：
高端流：所有的内存中的流都是高端流，比如：InputStreamReader  
低端流：所有的外界设备中的流都是低端流，比如InputStream，OutputStream 
如何区分：所有的流对象的后缀中包含Reader或者Writer的都是高端流，反之，则基本上为低端流，不过也有例外，比如PrintStream就是高端流

2、根据数据的流向来分：
输出流：是用来写数据的，是由程序（内存）--->外界设备
输入流：是用来读数据的，是由外界设备--->程序（内存）
如何区分：一般来说输入流带有Input，输出流带有Output 

3、根据流数据的格式来分：
字节流：处理声音或者图片等二进制的数据的流，比如InputStream 
字符流：处理文本数据（如txt文件）的流，比如InputStreamReader  
如何区分：可用高低端流来区分，所有的低端流都是字节流，所有的高端流都是字符流

4、根据流数据的包装过程来分：
原始流：在实例化流的对象的过程中，不需要传入另外一个流作为自己构造方法的参数的流，称之为原始流。
包装流：在实例化流的对象的过程中，需要传入另外一个流作为自己构造方法发参数的流，称之为包装流。
如何区分：所以的低端流都是原始流，所以的高端流都是包装流

IO流对象的继承关系(如下图)：

下面来看一些具体的代码例子：

1.将一个文件的内容写入另一个文件(按行来写)

<span style="white-space:pre">	</span>/**
	 * 将一个文件的内容写入另一个文件(按行来写)<br>
	 * 
	 * @param source 源文件
	 * @param target 目标文件
	 */
	public static void readFileToAnother(String source, String target) {
		File sourceFile = new File(source);

		BufferedReader read = null;
		BufferedWriter writer = null;

		try {
			// 源文件读取对象缓冲读入流
			read = new BufferedReader(new FileReader(sourceFile));
			
			// 目标文件写入对象缓冲写入流
			writer = new BufferedWriter(new FileWriter(target));
		} catch (IOException e) {
			e.printStackTrace();
		}

		try {
			String tempString = null;
			while (null != (tempString = read.readLine())) {
				writer.append(tempString);
				writer.newLine();// 换行
				writer.flush();// 需要及时清掉流的缓冲区，万一文件过大就有可能无法写入了,Soga!
			}

			read.close();
			writer.close();
			System.out.println("文件写入完成...");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

2.以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件<br>

	/**
	 * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件<br>
	 * @param fileName 文件路径
	 */
	public static void readFileByBytes(String fileName) {
		File file = new File(fileName);
		InputStream is = null;
		
		// 一次读一个字节
		System.out.println("一次读一个字节：");
		try {
			is = new FileInputStream(file);
			int tempbyte;
			while (-1 != (tempbyte = is.read())) {
				System.out.print(tempbyte);
			}
			System.out.println();
			is.close();
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
		
		// 一次读多个字节
		System.out.println("一次读多个字节：");
		try {
			is = new FileInputStream(fileName);
			int available = is.available();
			System.out.println("此字节流一次可读取的字节数：" + available);
			
			// 设置一次读取100个字节
			byte[] tempbytes = new byte[100];
			
			int byteread = 0;
			// 读入多个字节到字节数组中，byteread为一次读入的字节数
			while (-1 != (byteread = is.read(tempbytes))) {
				System.out.print(tempbytes + "->" + byteread);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (is != null) {
				try {
					is.close();
				} catch (IOException e1) {
				}
			}
		}
	}

3.以行为单位读取文件，常用于读面向行的格式化文件

	/**
	 * 以行为单位读取文件，常用于读面向行的格式化文件
	 * 
	 * @param fileName 文件路径
	 */
	public static void readFileByLines(String fileName) {
		File file = new File(fileName);
		BufferedReader reader = null;

		try {
			reader = new BufferedReader(new FileReader(file));

			String tempString = null;
			int line = 1;
			// 一次读入一行，直到读入null为文件结束
			while (null != (tempString = reader.readLine())) {
				// 显示行号
				System.out.println("line " + line + ": " + tempString);
				line++;
			}
			reader.close();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e1) {
				}
			}
		}
	}

4.以字符为单位读取文件，常用于读文本，数字等类型的文件

	/**
	 * 以字符为单位读取文件，常用于读文本，数字等类型的文件
	 * 
	 * @param fileName 文件路径
	 */
	public static void readFileByChars(String fileName) {
		File file = new File(fileName);
		Reader reader = null;

		// 一次读一个字符
		try {
			reader = new InputStreamReader(new FileInputStream(file));
			
			int tempchar;
			while (-1 != (tempchar = reader.read())) {
				// 对于windows下，\r\n这两个字符在一起时，表示一个换行。
				// 但如果这两个字符分开显示时，会换两次行。
				// 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
				if (((char) tempchar) != '\r') {
					System.out.print((char) tempchar);
				}
			}
			
			reader.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

		// 一次读多个字符
		try {
			
			// 由于要以字符来读取，所以需要套上字符流
			reader = new InputStreamReader(new FileInputStream(fileName));
			
			// 一次读30个字符
			char[] tempchars = new char[30];
			int charread = 0;
			// 读入多个字符到字符数组中，charread为一次读取字符数
			while (-1 != (charread = reader.read(tempchars))) {
				// 同样屏蔽掉\r不显示
				if ((charread == tempchars.length)
						&& (tempchars[tempchars.length - 1] != '\r')) {
					System.out.print(tempchars);
				} else {
					for (int i = 0; i < charread; i++) {
						if (tempchars[i] == '\r') {
							continue;
						} else {
							System.out.print(tempchars[i]);
						}
					}
				}
			}
		} catch (Exception e1) {
			e1.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e1) {
				}
			}
		}
	}