大数据之Java基础（二十一）：IO流---3

一、转换流

1.OutputStreamWriter类

• 概念

OutputStreamWriter是字符流通向字节流的桥梁，可以将字符串按照指定的编码转成字节

流，然后可以使用FileOutputStream将字节流写入到文件。

• 代码展示

	/*
	 * 使用OutputStreamWriter--将字节转成指定编码的字符,并写入文件
	 */
	public static void func4() throws IOException
	{
		File file = new File("d:\\a.txt");
		
		//创建字节输出流
		FileOutputStream fos = new FileOutputStream(file);
		//创建utf-8格式输出转换流
		OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
		//写入,注意：gbk是1个汉字2个字节，utf-8是1个汉字3个字节
		osw.write("你好");
		osw.flush();
		osw.close();	
	}

2.InputStreamReader类

• 概念

InputStreamReader类是字节流向字符的桥梁，可以将不同编码的文本转换成指定编码的字节流，然后可以通过FileInputStream读取字节流到内存中

• 代码展示

/*
	 * 使用InputStreamReader--将字符转成指定编码的字节流，并读入 内存
	 */
	public static void func5() throws IOException
	{
		File file = new File("d:\\a.txt");
		//创建字节输入流
		FileInputStream fis = new FileInputStream(file);
		
		//创建指定编码的转换流
		InputStreamReader isr = new InputStreamReader(fis,"gbk");
		
		//以指定的编码读取到内存中
		char [] cbuf = new char[1024];
		int len = 0;
		String str = "";
		while((len = isr.read(cbuf)) != -1)
		{
			for(int i = 0 ; i<len ; i++)
			{				
				str = str + cbuf[i];
			}			
		}
		System.out.println(str);	
	}

二、缓冲流

1.概念

读取数据量大的文件时，读取很慢，影响效率，所以，JAVA中提供了一套缓冲流，可提高IO的读写效率。缓冲流分为：字节缓冲流和字符缓冲流

2.字节缓冲输出流BufferedOutputStream

• 概念

通过字节缓冲流，进行文件的读写操作，写出数据到文件

• 构造方法

public BufferedOutputStream(OutputStream out); //参数为字节输出流

• 代码展示

/*
	 * 使用字节缓冲输出流：BufferedOutputStream进行输出
	 */
	public static void func1() throws IOException
	{
		File file = new File("d:\\a.txt");
		//创建字节输出流
		OutputStream os = new FileOutputStream(file);
		//创建字节缓冲输出流
		BufferedOutputStream bos = new BufferedOutputStream(os);
		bos.write("Hello".getBytes());
		bos.flush();
		bos.close();
	}

3.字节缓冲输入流BufferedInputream

• 概念

读取文件中的数据操作

• 构造方法

public BufferedInputStream(InputStream in);

• 代码展示

/*
	 * 使用BufferedInputStream 进行文件的读取操作
	 */
	public static void func2() throws IOException
	{
		File file = new File("d:\\a.txt");
		InputStream is = new FileInputStream(file);
		
		BufferedInputStream bis = new BufferedInputStream(is);
		byte[] bbuf = new byte[1024];
		int len = 0;
		String str = "";
		while((len = bis.read(bbuf)) != -1)
		{
			for(int i = 0; i<len ; i++)
			{
				str = str + (char)bbuf[i];
			}
		}
		System.out.println(str);
	
	}

4.使用字节缓冲流进行文件的复制操作

/*
	 * 使用字符缓冲流，进行文件的复制
	 */
	public static void func3() throws IOException
	{
		File srcFile = new File("d:\\a.txt");
		File desFile = new File("d:\\b.txt");
		
		InputStream is = new FileInputStream(srcFile);
		OutputStream os = new FileOutputStream(desFile);
		
		BufferedInputStream bis = new BufferedInputStream(is);
		BufferedOutputStream bos = new BufferedOutputStream(os);
		int len = 0;
		byte [] bbuf = new byte[1024];
		while((len = bis.read(bbuf)) != -1)
		{
			bos.write(bbuf,0,len);
			bos.flush();
		}
		bos.close();
		bis.close();	
	}

5.字符缓冲输出流BufferedWriter

• 概念

将文本写入输出流，缓冲各个字符，从而进行高效的输出

• 主要方法
  • public BufferedWriter(Writer); //参数为字符输出流
  • void newLine(); //根据当前系统，输出一个分隔符
  • void write(); //输出数据

• 代码展示

/*
	 * 使用字符缓冲输出流，将内存中的数据输出文件
	 */
	public static void func4() throws IOException
	{
		File file = new File("d:\\a.txt");
		Writer w = new FileWriter(file);
		BufferedWriter bw = new BufferedWriter(w);
		bw.write("HelloWorld");
		bw.newLine();		//换行，与系统无关
		bw.write("HelloWorld");
		bw.flush();
		bw.close();
	}

6.字符缓冲输入流BufferedReader

• 概念

进行高效的读取文件到内存

• 方法
  • public BufferedReader(Reader); //构造函数，参数为字符输入流
  • public String readLine(); //读取一个文本行，包含该内容的字符串，但是不包含任何终止符，如果已经达到流的末尾，返回null

• 代码展示

/*
	 * 使用字符缓冲输入流，将文本文件的内容读取到内存中
	 */
	public static void func5() throws IOException
	{
		File file = new File("d:\\a.txt");
		Reader r = new FileReader(file);
		BufferedReader br = new BufferedReader(r);
		String sbuf = "";
		String str = "";
		
		char[] cbuf = new char[1024];
		int len = 0;
		while((len = br.read(cbuf)) != -1)
		{
			for(int i = 0; i < len ; i++)
			{
				str = str + cbuf[i];
			}
		}
		
		
		while((sbuf = br.readLine())!= null)
		{
			//注意Readline不会读取换行符，终止符
			str = str + sbuf + "\r\n";
		}
		br.close();
		System.out.println(str);	
	}

7.使用字符缓冲流进行文本文件的复制

/*
	 * 使用字符缓冲流，进行文本文件的复制
	 */
	public static void func6() throws IOException
	{
		File srcFile = new File("d:\\a.txt");
		File desFile = new File("d:\\b.txt");
		
		Reader r = new FileReader(srcFile);
		Writer w = new FileWriter(desFile);
		
		BufferedReader br = new BufferedReader(r);
		BufferedWriter bw = new BufferedWriter(w);
		
		String str = "";
		while((str = br.readLine()) != null)
		{
			bw.write(str);
			bw.newLine();	//记得一定要写换行符，不然文本文件不换行
			bw.flush();
		}
		
//		char [] cbuf = new char[1024];
//		int len = 0;
//		while((len = br.read(cbuf)) != -1)
//		{
//			bw.write(cbuf,0,len);
//			bw.flush();
//		}
		br.close();
		bw.close();
	}

三、总结

1.规律整理：什么时候使用什么流

• 首先，要明确是操作字符还是字节；
• 如果是操作字符，那么就是Reader和Writer类及其子类 FileReader和FileWriter(快捷流，使用默认编码)、OutputStreamWriter和InputStreamReader(转换流，使用自定义编码)、BufferedReader和BufferedWriter(缓冲流，使用默认编码)；最后通过具体的功能，是快捷，还是指定编码，还是高效，选择使用对应的子类流。
• 如果是操作字节，那么就是InputStream和OutputStream类及其子类 FileInputStream和FileOutputStream（普通字节流，一般作为转换流和高效字节流的构造参数）、BufferedInputStream和BufferedOutputStream（高效字节流）；最后通过具体的功能，选择普通还是高效。

2.类整理

• 字节流
  • 字节输入流InputStream
    • FileInputStream:普通字节输入流
    • BufferedInputStream:高效的字节输入流，构造函数需要传入字节输入流
  • 字节输出流OutputStream
    • FileOutputStream:普通的字节输出流
    • BufferedOutputStream:高效的字节输出流，构造函数需要传入字节输出流

• 字符流
  • 字符输入流Reader
    • FileReader:快捷的字符输入流，使用默认编码
    • InputStreamReader:转换流，可以自定义编码
    • BufferedReader:缓冲流，高效读取，使用默认编码
  • 字符输出流Writer
    • FileWriter:快捷的字符输出流，使用默认编码
    • InputStreamWriter:转换流，可以自定义编码
    • BufferedWriter:缓冲流，高效输出，使用默认编码

3.方法整理

• read():一次读取一个字节，效率缓慢
• read(byte [] / char[] ):一次读取一个数组，效率高效
• readLine(); //针对BufferedReader,读取一行文本，但是不读取换行符
• write(int); //一次写入一个字节到文件中
• write(byte[] char[]); //一次写入一个数组到文件中
• write(String) //一次写入一个字符串到文件中
• newLine(); //BufferedWriter特有方法，写入一个换行符

全文完！