常见字符流

  常用的字符流有：

• FileReader/FileWriter，文件字符流（节点流）
• BufferedReader/BufferedWriter，字符缓存流（处理流）
• InputStreamReader/OutputStreamWriter，转换流（处理流）

  下面分别介绍一下这三组字符流及用法。

FileReader/FileWriter

  FileReader/FileWriter是最常用的字符流，当数据源为文本文件时，选择这组数据流进行处理。我们可以通过构造器快速了解它的操作数据类型：

    public FileReader(File file)

    public FileWriter(File file)

  它的使用基本与FileInputStream/FileOutputStream一致，只是数据单位是字符数组char[ ]。

  来一个文件的拷贝实例，了解其用法（对比着字节流看，更有感觉）：

public class FileRW {

	public static void main(String[] args) {
		//1.指定数据源
		File in_scr = new File("a.txt");
		File out_scr = new File("a-copy.txt");
		
		Reader reader = null;
		Writer writer = null;
		try {
			//2.选择合适的数据流
			reader = new FileReader(in_scr);
			writer = new FileWriter(out_scr);
			
			//3.进行数据操作
			char[] flush = new char[1024]; //字符流，数据以字符数组为单位
			int len = -1;
			while( (len = reader.read(flush)) != -1 ) {
				for(int i=0;i<len;i++) {
					System.out.print(flush[i]); //输出为字符
				}
				writer.write(flush, 0, len);
			}
			writer.flush();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//4.关闭流，释放资源
			//先打开的先关闭
			try {
				if(reader != null) {
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(writer != null) {
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

BufferedReader/BufferedWriter

  BufferedReader/BufferedWriter，字符缓存流（处理流），与BufferedInputStream/BufferedOutputStream类似，增加了缓存机制，大大提高了读写文本文件的效率。构造器源码如下：

    public BufferedReader(Reader in)

    public BufferedWriter(Writer out)

  同时，提供了更方便的按行读取的方法：readLine(); 处理文本时，我们一般可以使用缓冲字符流。

  BufferedReader/BufferedWriter也可以对FileReader/FileWriter进行装饰，然后继续使用read()方法。在这里就不再举例说明了。这里举一个使用readLine()方法的实例：

public class BufferedRW {

	public static void main(String[] args) {
		//1.指定数据源
		File in_scr = new File("a.txt");
		File out_scr = new File("a-copy.txt");
		
		BufferedReader reader = null;
		BufferedWriter writer = null;
		try {
			//2.选择合适的数据流
			reader = new BufferedReader(new FileReader(in_scr));
			writer = new BufferedWriter(new FileWriter(out_scr));
			
			//3.进行数据操作
			String str = null;
			while((str = reader.readLine()) != null) { //一行一行读
				writer.write(str); // 一行一行写，所以没有缓存，不需要flush()
				writer.newLine(); //换行
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//4.关闭流，释放资源
			//先打开的先关闭
			try {
				if(reader != null) {
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(writer != null) {
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

InputStreamReader/OutputStreamWriter

  InputStreamReader/OutputStreamWriter，转换流（处理流），是一种将字节流转化成字符流的处理流，构造器源码：

public class InputStreamReader extends Reader {
    public InputStreamReader(InputStream in)
}

public class OutputStreamWriter extends Writer {
    public OutputStreamWriter(OutputStream out)
}

  可以看到，InputStreamReader/OutputStreamWriter是继承了Reader/Writer的字符流，但是构造器中传入的是InputStream/OutputStream的字节流，内部实现了从字节流到字符流的转换。

  使用实例：

public class StreamRW {

	public static void main(String[] args) {
		//1.指定数据源
		File in_scr = new File("a.txt");
		File out_scr = new File("a-copy.txt");
		
		
		BufferedReader reader = null;
		BufferedWriter writer = null;
		try {
			FileInputStream fis = new FileInputStream(in_scr);
			FileOutputStream fos = new FileOutputStream(out_scr);
			
			//2.选择合适的数据流
			reader = new BufferedReader(new InputStreamReader(fis));//对InputStreamReader来说，数据源是FileInputStream字节流
			writer = new BufferedWriter(new OutputStreamWriter(fos));//对OutputStreamWriter来说，数据源是FileOutputStream字节流
			//从字节流转换为了字符流，然后再使用BufferedWriter进行处理装饰，后续操作就可以按字符流进行处理了
			//3.进行数据操作
			String str = null;
			while((str = reader.readLine()) != null) {
				writer.write(str);
				writer.newLine();
			}
		
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//4.关闭流，释放资源
			//先打开的先关闭
			try {
				if(reader != null) {
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(writer != null) {
					writer.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}