IO流的学习-缓冲流

1.缓冲流

字节缓冲流根据流的方向，共有2个
	写入数据到流中，字节缓冲输出流 BufferedOutputStream
	读取流中的数据，字节缓冲输入流 BufferedInputStream

它们的内部都包含了一个缓冲区，通过缓冲区读写，就可以提高了IO流的读写速度

2.输出流缓冲流BufferedOutputStream

	* A: 字节输出流缓冲流BufferedOutputStream
		* a: BufferedOutputStream
			* 字节输出流的缓冲流
			* java.io.BufferedOuputStream 作用: 提高原有输出流的写入效率
			* BufferedOuputStream 继承 OutputStream
			* 方法,写入 write 字节,字节数组			 
			* 构造方法:
				* BufferedOuputStream(OuputStream out)
				* 可以传递任意的字节输出流, 传递的是哪个字节流,就对哪个字节流提高效率

public static void main(String[] args)throws IOException {
					//创建字节输出流,绑定文件
					//FileOutputStream fos = new FileOutputStream("c:\\buffer.txt");
					//创建字节输出流缓冲流的对象,构造方法中,传递字节输出流
					BufferedOutputStream bos = new
							BufferedOutputStream(new FileOutputStream("c:\\buffer.txt"));
					
					bos.write(55);
					
					byte[] bytes = "HelloWorld".getBytes();
					
					bos.write(bytes);
					
					bos.write(bytes, 3, 2);
					
					bos.close();
				}

3.输入流缓冲流BufferedInputStream

		* a: BufferedInputStream
			* 字节输入流的缓冲流
			* 继承InputStream,标准的字节输入流
			* 读取方法  read() 单个字节,字节数组			  
			* 构造方法:
				* BufferedInputStream(InputStream in)
				* 可以传递任意的字节输入流,传递是谁,就提高谁的效率
				* 可以传递的字节输入流 FileInputStream

			public class BufferedInputStreamDemo {
				public static void main(String[] args) throws IOException{
					//创建字节输入流的缓冲流对象,构造方法中包装字节输入流,包装文件
					BufferedInputStream bis = new 
							BufferedInputStream(new FileInputStream("c:\\buffer.txt"));
					byte[] bytes = new byte[10];
					int len = 0 ;
					while((len = bis.read(bytes))!=-1){
						System.out.print(new String(bytes,0,len));
					}
					bis.close();
				}
			}

4.四种文件复制方式的效率比较

			* 字节流读写单个字节                    125250 毫秒
			* 字节流读写字节数组                    193    毫秒  OK
			* 字节流缓冲区流读写单个字节    		1210   毫秒
			* 字节流缓冲区流读写字节数组            73     毫秒  OK	

				/*
				 * 方法,实现文件复制
				 *  4. 字节流缓冲区流读写字节数组
				 */
				public static void copy_4(File src,File desc)throws IOException{
					BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
					BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
					int len = 0 ;
					byte[] bytes = new byte[1024];
					while((len = bis.read(bytes))!=-1){
						bos.write(bytes,0,len);
					}
					bos.close();
					bis.close();
				}
				/*
				 * 方法,实现文件复制
				 *  3. 字节流缓冲区流读写单个字节
				 */
				public static void copy_3(File src,File desc)throws IOException{
					BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
					BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
					int len = 0 ;
					while((len = bis.read())!=-1){
						bos.write(len);
					}
					bos.close();
					bis.close();
				}
				
				/*
				 * 方法,实现文件复制
				 *  2. 字节流读写字节数组
				 */
				public static void copy_2(File src,File desc)throws IOException{
					FileInputStream fis = new FileInputStream(src);
					FileOutputStream fos = new FileOutputStream(desc);
					int len = 0 ;
					byte[] bytes = new byte[1024];
					while((len = fis.read(bytes))!=-1){
						fos.write(bytes,0,len);
					}
					fos.close();
					fis.close();
				}
				
				/*
				 * 方法,实现文件复制
				 *  1. 字节流读写单个字节
				 */
				public static void copy_1(File src,File desc)throws IOException{
					FileInputStream fis = new FileInputStream(src);
					FileOutputStream fos = new FileOutputStream(desc);
					int len = 0 ;
					while((len = fis.read())!=-1){
						fos.write(len);
					}
					fos.close();
					fis.close();
				}
			}

5.字符输出流缓冲流BufferedWriter

	* A: 字符输出流缓冲流BufferedWriter
		* a: BufferedWriter
			* 字符输出流缓冲区流
			* java.io.BufferedWriter 继承 Writer
			* 写入方法 write () 单个字符,字符数组,字符串
  
			* 构造方法:
				* BufferedWriter(Writer w)传递任意字符输出流
				* 传递谁,就高效谁
				* 能传递的字符输出流 FileWriter, OutputStreamWriter

			public class BufferedWrierDemo {
				public static void main(String[] args) throws IOException{
					//创建字符输出流,封装文件
					FileWriter fw = new FileWriter("c:\\buffer.txt");
					BufferedWriter bfw = new BufferedWriter(fw);
					
					bfw.write(100);
					bfw.flush();
					bfw.write("你好".toCharArray());
					bfw.flush();
					
					
					bfw.write("你好");
					
					bfw.flush();
					
					
					bfw.write("我好好");
					
					bfw.flush();

					bfw.write("大家都好");
					bfw.flush();
					
					bfw.close();
					
				}
			}

6.字符输出流缓冲流BufferedWriter，以及特有方法newLine

注意：

1.new line（）这个方法，可以换行。或者使用 \r\n 换行效果，存在于文本，不存在控制台。

* a: 方法介绍
			* void  newLine() 写换行
				
			* newLine()文本中换行, \r\n也是文本换行
			* 方法具有平台无关性
			* Windows  \r\n
			* Linux    \n
				 
			* newLine()运行结果,和操作系统是相互关系
			* JVM: 安装的是Windows版本,newLine()写的就是\r\n
			* 安装的是Linux版本,newLine()写的就是\n
			/*
			 *  将数据源 c:\\a.txt
			 *  复制到 d:\\a.txt  数据目的
			 *  字节输入流,绑定数据源
			 *  字节输出流,绑定数据目的
			 *  
			 *  输入,读取1个字节
			 *  输出,写1个字节

			public class BufferedWrierDemo {
				public static void main(String[] args) throws IOException{
					//创建字符输出流,封装文件
					FileWriter fw = new FileWriter("c:\\buffer.txt");
					BufferedWriter bfw = new BufferedWriter(fw);
					
					bfw.write(100);
					bfw.flush();
					bfw.write("你好".toCharArray());
					bfw.flush();
					
					bfw.write("你好");
					bfw.newLine();
					bfw.flush();
					
					
					bfw.write("我好好");
					bfw.newLine();
					bfw.flush();

					bfw.write("大家都好");
					bfw.flush();
					
					bfw.close();
					
				}
			}

7.输入流缓冲流BufferedReader

1.子类LineNumberReader在读取时，可以显示行号。

		* a: 概述
			* 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取
			* public String readLine() 读取一个文本行，包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

* A: 字符输入流缓冲流BufferedReader读取文本行
		* a: BufferedReader
			* 字符输入流缓冲流
			* java.io.BufferedReader 继承 Reader
			* 读取功能 read() 单个字符,字符数组
			* 构造方法:
				* BufferedReader(Reader r)
				* 可以任意的字符输入流
				   FileReader  InputStreamReader       
			* BufferedReader自己的功能
				* String readLine() 读取文本行 \r\n   
					* 方法读取到流末尾,返回null
		* b: 小特点
			 * 获取内容的方法一般都有返回值
			 * int 没有返回的都是负数
			 * 引用类型 找不到返回null
			 * boolean 找不到返回false
			
		* c: 案例代码
			public class BufferedReaderDemo {
				public static void main(String[] args) throws IOException {
					int lineNumber = 0;
					//创建字符输入流缓冲流对象,构造方法传递字符输入流,包装数据源文件
					BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt"));
					//调用缓冲流的方法 readLine()读取文本行
					//循环读取文本行, 结束条件 readLine()返回null
					String line = null;
					while((line = bfr.readLine())!=null){
						lineNumber++;
						System.out.println(lineNumber+"  "+line);
					}
					bfr.close();
				}
			}

			/*
			 * String line = bfr.readLine();
					System.out.println(line);
					
					line = bfr.readLine();
					System.out.println(line);
					
					line = bfr.readLine();
					System.out.println(line);
					
					line = bfr.readLine();
					System.out.println(line);
					
					line = bfr.readLine();
					System.out.println(line);
			 */

8.字符流缓冲区流复制文本文件

注意：

1.根据以下判断，会比源文件多出2个字节，这两个字节是空行。

因为当复制一行结束时，会先空行，在去判断是否有字符，当没有字符时，这个预留的空行依旧存在，就会导致多字节，多空行的问题。

可以从判断中，去优化。暂不做研究。

	* A: 字符流缓冲区流复制文本文件
		* a: 案例代码
			/*
			 *  使用缓冲区流对象,复制文本文件
			 *  数据源  BufferedReader+FileReader 读取
			 *  数据目的 BufferedWriter+FileWriter 写入
			 *  读取文本行, 读一行,写一行,写换行
			 */
			public class Copy_1 {
				public static void main(String[] args) throws IOException{
					BufferedReader bfr = new BufferedReader(new FileReader("c:\\w.log"));	
					BufferedWriter bfw = new BufferedWriter(new FileWriter("d:\\w.log"));
					//读取文本行, 读一行,写一行,写换行
					String line = null;
					while((line = bfr.readLine())!=null){
						bfw.write(line);
						bfw.newLine();
						bfw.flush();
					}
					bfw.close();
					bfr.close();
				}
			}

9.IO流对象的操作规律

注意：

1.

InputStream:字节输入流的基类

OutputStream：字节输出流的基类

Reader:字符输入流的基类

Writer：字符输出流的基类

2.

字节是万能的：InputStream,OutputStream

字符只文本的:Reader,Write

3.IO流可以操作内存，从内存中读取，只是还没涉及到。

* A: IO流对象的操作规律
		* a: 明确一：要操作的数据是数据源还是数据目的。
			* 源：InputStream    Reader
			* 目的：OutputStream Writer
			* 先根据需求明确要读，还是要写。

		* b: 明确二：要操作的数据是字节还是文本呢？
			* 源：
				* 字节：InputStream
				* 文本：Reader
			* 目的：
				* 字节：OutputStream
				* 文本：Writer
		* c: 明确三：明确数据所在的具体设备。
			* 源设备：
				* 硬盘：文件  File开头。
				* 内存：数组，字符串。
				* 键盘：System.in;
				* 网络：Socket
			* 目的设备：
				* 硬盘：文件  File开头。
				* 内存：数组，字符串。
				* 屏幕：System.out
				* 网络：Socket
				* 完全可以明确具体要使用哪个流对象。
		* d: 明确四：是否需要额外功能呢？
			* 额外功能：
				* 转换吗？转换流。InputStreamReader OutputStreamWriter
				* 高效吗？缓冲区对象。BufferedXXX
				* 已经明确到了具体的体系上。

10.总结

 

	字节流
	字节输入流 InputStream
	FileInputStream 操作文件的字节输入流
	BufferedInputStream高效的字节输入流
	字节输出流 OutputStream
	FileOutputStream 操作文件的字节输出流
	BufferedOutputStream 高效的字节输出流
	字符流
	字符输入流 Reader
	FileReader 操作文件的字符输入流
	BufferedReader 高效的字符输入流
	InputStreamReader 输入操作的转换流(把字节流封装成字符流)
	字符输出流 Writer
	FileWriter 操作文件的字符输出流
	BufferedWriter 高效的字符输出流
	OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)

	方法：
	读数据方法：
	read() 一次读一个字节或字符的方法
	read(byte[]  char[]) 一次读一个数组数据的方法
	readLine() 一次读一行字符串的方法(BufferedReader类特有方法)
	readObject() 从流中读取对象(ObjectInputStream特有方法)
	写数据方法：
	write(int) 一次写一个字节或字符到文件中
	write(byte[] char[]) 一次写一个数组数据到文件中
	write(String) 一次写一个字符串内容到文件中
	writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)
	newLine() 写一个换行符号(BufferedWriter类特有方法)

	向文件中写入数据的过程
1，创建输出流对象
2，写数据到文件
3，关闭输出流
	从文件中读数据的过程
1，	创建输入流对象
2，	从文件中读数据
3，	关闭输入流

	文件复制的过程
1，	创建输入流（数据源）
2，	创建输出流（目的地）
3，	从输入流中读数据
4，	通过输出流，把数据写入目的地
5，	关闭流