24_IO_第24天（转换流、缓冲流）_讲义

小咪咪 2022-04-12 04:19 202阅读 0赞

# 第24天 IO流 #

今日内容介绍  
 转换流  
 缓冲流

## 01转换流概述 ##

*  A: 转换流概述
    
     *  a: 转换流概述
        
         *  **OutputStreamWriter** 是**字符流通向字节流**的桥梁：可使用指定的字符编码表，将要写入流中的字符编码成字节
         *  将字符串按照指定的编码表转成字节，在使用字节流将这些字节写出去

## 02转换流\_字符转字节的过程 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]

## 03OutputStreamWriter写文本文件 ##

*  A: OutputStreamWriter写文本文件
    
     *  a: OutputStreamWriter
        
         *  java.io.OutputStreamWriter 继承Writer类
         *  就是一个字符输出流，写文本文件
         *  write()字符，字符数组，字符串
         *  **字符通向字节的桥梁，将字符流转字节流**
         *  OutputStreamWriter 使用方式
            
             *  构造方法：
                
                 *  OutputStreamWriter(OuputStream out)接收所有的字节输出流
                 *  **字节输出流： FileOutputStream**
                 *  OutputStreamWriter(OutputStream out, String charsetName)
                 *  String charsetName 传递编码表名字 GBK UTF-8
         *  OutputStreamWriter 有个子类， FileWriter  
            文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。文件是否可用或能否可以被创建取决于基础平台。特别是某些平台一次只允许一个 FileOutputStream（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。  
            **FileOutputStream 用于写入诸如图像数据之类的原始字节的流。要写入字符流，请考虑使用 FileWriter**  
            ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]

**OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集**  
每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。注意，传递给 write() 方法的字符没有缓冲。

**为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]

*  b: 案例代码

package cn.itcast.demo;
    /*
     * 查阅OutputStreamWriter的API介绍
     * OutputStreamWriter 是字符流通向字节流的桥梁
     * 可使用指定的字符编码表
     * 将要写入流中的字符编码成字节
     * 它的作用的就是: 将字符串按照指定的编码表转成字节，在使用字节流将这些字节写出去
     */
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
    
    /*
     * 转换流
     * 	java.io.OutputStreamWriter  继承Writer类
     *  就是一个字符输出流,写文本文件
     *  write()字符,字符数组,字符串
     *  
     *  字符流通向字节流的桥梁,可以字符将流转成字节流
     */
    public class OutputStreamWriterDemo {
    	public static void main(String[] args) throws IOException {
    		writeUTF();
    		writeGBK();
    	}
    	/*
    	 * 转换流对象OutputStreamWriter写文本
    	 * 采用UTF-8编码表写入
    	 */
    	public static void writeUTF() throws IOException{
    		//创建字节输出流,绑定文件
    		FileOutputStream fos = new FileOutputStream("E:\\utf.txt");
    		//创建转换流对象,构造方法保证字节输出流,并指定编码表是UTF-8
    		OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
    		osw.write("你好");
    		osw.close();
    	}
    	/*
    	 * 转换流OutputStreamWriter写文本
    	 * 文本采用GBK的形式写入
    	 */
    	public static void writeGBK() throws IOException{
    		//创建字节输出流,绑定数据文件
    		FileOutputStream fos = new FileOutputStream("E:\\gbk.txt");
    		//创建转换流对象,构造方法,绑定字节输出流,使用GBK编码表
    		OutputStreamWriter osw = new OutputStreamWriter(fos);
    		//转换流写数据
    		osw.write("您好");
    		osw.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]

## 04转换流\_字节转字符流过程 ##

*  A: 转换流\_字节转字符流过程
    
     *  a: InputStreamReader
        
         *  java.io.InputStreamReader 继承 Reader
         *  字符输入流，读取文本文件
         *  字节流向字符的敲了，将字节流转字符流
         *  读取的方法:
            
             *  read() 读取1个字符，读取字符数组
         *  技巧
            
             *  OuputStreamWriter写了文件
             *  InputStreamReader读取文件
         *  OutputStreamWriter(OutputStream out)所有字节输出流
         *  **InputStreamReader(InputStream in) 接收所有的字节输入流**
         *  **可以传递的字节输入流： FileInputStream**
         *  **InputStreamReader(InputStream in,String charsetName) 传递编码表的名字**
     *  b: 图解
        
         *  详见day24\_source/转换流.JPG图片

## 05InputSteamReader读取文本文件 ##

**InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集**。  
每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。  
**为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]

InputSteamReader读取文本文件：案例代码

package cn.itcast.demo;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    /* 
     * InputStreamReader读取文本文件
     * 
     */
    public class InputStreamReaderDemo {
    	public static void main(String[] args) throws IOException {
    		readUTF();
    		readGBK();
    	}
    	/*
    	 * 转换流,InputStreamReader读取文本
    	 * 采用UTF-8编码表,读取文件utf
    	 */
    	public static void readUTF() throws IOException{
    		//创建自己输入流,传递文本文件
    		FileInputStream fis = new FileInputStream("E:\\utf.txt");
    		//创建转换流对象,构造方法中,包装字节输入流,同时写编码表名
    		InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
    		char[] ch = new char[1024];
    		int len = isr.read(ch);
    		System.out.println(new String(ch,0,len));
    		isr.close();
    	}
    	/*
    	 * 转换流,InputStreamReader读取文本
    	 * 采用系统默认编码表,读取GBK文件
    	 */
    	public static void readGBK() throws IOException{
    		//创建自己输入流,传递文本文件
    		FileInputStream fis = new FileInputStream("E:\\gbk.txt");
    		//转换转换流,构造方法,包装字节输入流
    		InputStreamReader isr = new InputStreamReader(fis);
    		char[] ch = new char[1024];
    		int len = isr.read(ch);
    		System.out.println(new String(ch,0,len));
    		isr.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]

## 06转换流子类父类的区别 ##

*  A: 转换流子类父类的区别
 *  a: 继承关系  
    OutputStreamWriter:  
    |–FileWriter:  
    InputStreamReader:  
    |–FileReader;
 *  b: 区别
    
     *  **OutputStreamWriter和InputStreamReader是字符和字节的桥梁**：
     *  也可以称之为字符转换流。字符转换流原理：字节流+编码表。
     *  FileWriter和FileReader：作为子类，仅作为操作字符文件的便捷类存在。  
        当操作的字符文件，使用的是默认编码表时可以不用父类，而直接用子类就完成操作了，简化了代码。
 *  以下三句话功能相同
 *  InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”));//默认字符集GBK。
 *  InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”),“GBK”);//指定GBK字符集。
 *  FileReader fr = new FileReader(“a.txt”);  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]

## 07缓冲流概述 ##

*  A: 缓冲流概述
    
     *  a: 概述
        
         *  可提高IO流的读写速度
         *  分为字节缓冲流与字符缓冲流

## 08字节输出流缓冲流BufferedOutputStream ##

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]  
![在这里插入图片描述][20181201102613316.png]

*  b: 案例代码

package cn.itcast.demo1;
    
    import java.io.BufferedOutputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * 字节输出流的缓冲流
     * 	java.io.BufferedOutputStream 作用：提高原有输出流的写入效率
     *  BufferedOutputStream 继承OutputStream
     *  方法,写入write字节,字节数组
     *  
     *  构造方法：FileOutputStream
     * 		 BufferedOutputStream(OutputStream out) 
     * 			可以传递任意的字节输出流,传递的事哪一个字节流,就对哪个字节流提高效率
     * 		 BufferedOutputStream(OutputStream out, int size) 
    			创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
     *  
     *  void write(byte[] b, int off, int len)  
     *    将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
     *  void write(int b)  将指定的字节写入此缓冲的输出流
     */
    public class BufferedOutputStreamDemo {
    	public static void main(String[] args) throws IOException {
    		//创建字节输出流,绑定文件
    		//FileOutputStream fos = new FileOutputStream("E:\\buffer.txt");
    		//创建字节输出流缓冲流的对象,构造方法中,传递字节输出流
    		BufferedOutputStream bos = new 
    				BufferedOutputStream(new FileOutputStream("E:\\buffer.txt"));
    		
    		bos.write(55);
    		//byte[] getBytes() 
            //使用平台的默认字符集将此 String 编码为 byte 序列
    		//并将结果存储到一个新的 byte 数组中 
    		byte[] bytes = "HelloWord".getBytes();
    		
    		//void write(int b) 
    		//将指定的字节写入此缓冲的输出流 
    		bos.write(bytes);
    		
    		//void write(byte[] b, int off, int len)  
    		//将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
    		bos.write(bytes, 3, 2);
    		
    		bos.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 17]

## 09字节输入流缓冲流BufferedInputStream ##

*  A: 字节输入流缓冲流BufferedInputStream
    
     *  a: BufferedInputStream
        
         *  字节输入流的缓冲流
         *  继承InputStream,标准的字节输入流
         *  读取方法 read() 单个字节,字节数组
         *  构造方法:
            
             *  **BufferedInputStream(InputStream in)**
             *  **可以传递任意的字节输入流,传递是谁,就提高谁的效率**
             *  **可以传递的字节输入流 FileInputStream**  
                ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 18]  
                ![在这里插入图片描述][20181201103258439.png]  
                ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 19]
 *  b: 案例代码

package cn.itcast.demo1;
    /*
     * 字节输入流的缓冲流
     * 		java.io.BufferedInputStream
     * 			继承 InputStream,标准的字节输入流
     * 		读取方法read() 单个字节,字节数组
     * 
     * 构造方法：
     * 		BufferedInputStream(InputStream in) 
     * 			可以传递任意的字节输入流,传递是谁,就提高谁的效率
     * 			可以传递的字节输入流FileInputStream
     */
    import java.io.BufferedInputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /*
     * 字节输入流的缓冲流
     * 	   
     */
    public class BufferedInputStreamDemo {
    	public static void main(String[] args) throws IOException {
    		//System.out.println(System.in);//java.io.BufferedInputStream@1774b9b
    		//System.out.println(System.out);//java.io.PrintStream@104c575
    		//创建字节输入流的缓冲流对象,构造方法中包装字节输入流,包装文件
    		BufferedInputStream bis = new 
    				BufferedInputStream(new FileInputStream("E:\\buffer.txt"));
    		byte[] bytes = new byte[10];
    		int len = 0;
    		while((len = bis.read(bytes)) != -1){
    			//String(byte[] bytes, int offset, int length)
    			//通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String
    			System.out.print(new String(bytes,0,len));
    		}
    		bis.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 20]

## 10四种文件复制方式的效率比较 ##

*  A：四种文件复制方式的效率比较
    
     *  a: 四中复制方式
        
         *  字节流读写单个字节 125250 毫秒
         *  字节流读写字节数组 193 毫秒 OK
         *  字节流缓冲区流读写单个字节 1210 毫秒
         *  字节流缓冲区流读写字节数组 73 毫秒 OK
 *  b: 案例代码

package cn.itcast.copy;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * 
     */
    public class CopyDemo {
    
    	public static void main(String[] args) throws IOException {
    		long s = System.currentTimeMillis();
    		//copy_4(new File("E:\\a.pdf"),new File("F:\\a.pdf"));
    		//copy_3(new File("E:\\a.pdf"),new File("F:\\a.pdf"));
    		//copy_2(new File("E:\\a.pdf"),new File("F:\\a.pdf"));
    		copy_1(new File("E:\\a.pdf"),new File("F:\\a.pdf"));
    		long e = System.currentTimeMillis();
    		System.out.println(e-s);
    	}
    	/*
    	 * 方法,实现文件复制
    	 * 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){
    			//void write(int b) 
    			//将指定的字节写入此缓冲的输出流
    			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();
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 21]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 22]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 23]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 24]

## 11字符输出流缓冲流BufferedWriter ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 25]  
![在这里插入图片描述][20181201162625409.png]

*  A: 字符输出流缓冲流BufferedWriter
    
     *  a: BufferedWriter
        
         *  字符输出流缓冲区流
         *  java.io.BufferedWriter 继承 Writer
         *  写入方法 write () 单个字符,字符数组,字符串
         *  构造方法:
            
             *  BufferedWriter(Writer w)传递任意字符输出流
             *  传递谁,就高效谁
             *  能传递的字符输出流 FileWriter, OutputStreamWriter  
                ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 26]
     *  b: 案例代码

package cn.itcast.demo2;
    
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /*
     * 字符输出流缓冲区流
     * 		java.io.BufferedWriter 继承Writer
     *      写入方法write()单个字符,字符数组,字符串
     *      
     *      构造方法：
     *      	BufferedWriter(Writer w)传递任意字符输出流
     *      	传递谁,就高效率
     *      		能传递的字符输出流FileWriter,OutputStreamWriter
     *     BufferedWriter 具有自己特有的方法
     *     		void newLine()  写入一个行分隔符
     *     			newLine() 文本中换行,\r\n ---也是文本换行
     *     		方法具有平台无关性
     *     		Windows里换行符-- \r\n
     *     		Linux里换行符--  \n
     *     		newLine() 运行结果,和操作系统是相互关联的
     *     		JVM:安装的是Windows版本,newLine() 写的就是\r\n
     *     			安装的是Linux版本,newLine() 写的就是\n
     */
    public class BufferedWriterDemo {
    	public static void main(String[] args) throws IOException {
    		//创建字符输出流,封装文件
    		FileWriter fw = new FileWriter("E:\\buffer.txt");
    		BufferedWriter bfw = new BufferedWriter(fw);
    		System.out.println();// newLine();
    		//bfw.write(100);
    		//bfw.flush();		
    		//bfw.write("您好".toCharArray());
    		//bfw.flush();
    		
    		//bfw.write("嘿嘿\r\n");
    		//bfw.flush();
    		
    		//bfw.write("哈哈\r\n");
    		//bfw.flush();
    	
    		//bfw.write("大家都好");
    		//bfw.flush();
    		
    		bfw.write("1嘿嘿");
    		bfw.newLine();
    		bfw.flush();
    		
    		bfw.write("哈哈");
    		bfw.newLine();
    		bfw.flush();
    		
    		bfw.write("大家都好");
    		bfw.flush();
    		
    		bfw.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 27]

## 12字符输出流缓冲流BufferedWriter特有方法newLine ##

*  A: 字符输出流缓冲流BufferedWriter特有方法newLine
    
     *  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个字节  
            \*/

## 13字符输入流缓冲流BufferedReader ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 28]  
![在这里插入图片描述][20181201162715196.png]

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

## 14字符输入流缓冲流BufferedReader读取文本行 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 29]

*  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: 案例代码

package cn.itcast.demo2;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    
    /*
     * 字符输入流缓冲流
     * 		java.io.BufferedReader
     * 		读取功能read()单个字符,字符数组
     * 		构造方法：
     * 			BufferedReader(Reader r)
     * 			可以任意的字符输入流
     * 				FileReader  InputStreamReader
     * 			BufferedReader自己的功能
     * 			String readLine() 读取文本行\r\n
     * 			
     * 			方法读取到流末尾,返回null
     * 			小特点:
     * 				获取内容的方法一般都有返回值
     * 				int 没有返回的都是负数
     * 				引用类型  找不到返回null
     * 				boolean 找不到返回false
     * 				String s = null
     * 				String s = "null"  "null"-- 文本中能读到的内容
     * 				readLine()方法 只返回行的有效字符,没有\r\n
     */
    public class BufferedReaderDemo {
    	public static void main(String[] args) throws IOException {
    		//创建字符输入流缓冲流对象,构造方法传递字符输入流,包装数据源文件
    		BufferedReader bfr = new 
    				BufferedReader(new FileReader("E:\\a.txt"));
    		//调用缓冲流的方法readLine()读取文本行
    		//循环读取文本行,结束条件readLine()返回null
    		String line = null;
    		int lineNumber = 0;
    		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);
    	
    	line = bfr.readLine();
    	System.out.println(line);
    	
    	bfr.close();
     */

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 30]

## 15字符流缓冲区流复制文本文件 ##

*  A: 字符流缓冲区流复制文本文件
    
     *  a: 案例代码  
        /\*
        
         *  使用缓冲区流对象,复制文本文件
         *  数据源 BufferedReader+FileReader 读取
         *  数据目的 BufferedWriter+FileWriter 写入
         *  读取文本行, 读一行,写一行,写换行  
            \*/

package cn.itcast.copy;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /*
     * 使用缓冲区流对象,复制文本文件
     * 数据源BufferedReader+FileReader 读取
     * 数据目的BufferedWriter+FileWriter 写入
     * 读取文本行,读一行,写一行,写换行
     */
    public class Copy_1 {
    	public static void main(String[] args) throws IOException {
    		BufferedReader bfr = new BufferedReader(new FileReader("E:\\w.log"));
    		BufferedWriter bfw = new BufferedWriter(new FileWriter("F:\\w.log"));
    		//读取文本行,读一行,写一行,写换行
    		String line = null;
    		while((line = bfr.readLine()) != null){
    			bfw.write(line);
    			bfw.newLine();//复制文本文件多一个空行  目的比源文件多两个字节
    			bfw.flush();
    		}
    		bfw.close();
    		bfr.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 31]

## 16IO流对象的操作规律 ##

*  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
             *  已经明确到了具体的体系上。
             *

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20220412/acf5ccf32ef24659b3c550db6692518b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20220412/ae9192217eac4234b8247ea6db6d0e4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20220412/347169d3a09845408e723d289dcd5c1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20220412/7921aec0cf134743947840e40a65cf87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20220412/30f82e45de69431f9afcaf4a5e00e51d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20220412/ea865e4bf519493e9bed431bcbaf331a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20220412/1e3a366b7ee546079682587e00f6ed9f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20220412/386663723cb74bbf85940e80e320e288.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20220412/21a7fc8581534eb694a5c45ab4a6d8c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]: /images/20220412/56562e23cce84fc5afcd21d670cfcccb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]: /images/20220412/cca90d7bb15f4860b7412965264dc70a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]: /images/20220412/3cb0bb2dba7342bd8a81755467fc2147.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]: /images/20220412/8a563f4600714777a9e3d5f3a9daa52b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]: /images/20220412/cbca09bc7f904ca4971dd178db3d5133.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]: /images/20220412/2d39ff8b1dab49f99c9c7c01734bf0c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]: /images/20220412/34e5f67c1ce94d848d1ab4e79ef9f27a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]: /images/20220412/cb56a0caccb046d8880afa8aac80c84b.png
[20181201102613316.png]: /images/20220412/3a46590ba9384af4872cb805cdecce1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 17]: /images/20220412/7e8571b585f949e68c7a9fb785b90d98.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 18]: /images/20220412/20789535902845c78ddd90edcbb6b509.png
[20181201103258439.png]: /images/20220412/c61d164d149448619c78752a4c5f15b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 19]: /images/20220412/e5db82222327463ab57c3e7b07cb9339.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 20]: /images/20220412/676f0a7233d6461cada1bf9692542d7e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 21]: /images/20220412/3875f47757f84e07905127a72ae5444a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 22]: /images/20220412/e99c41d981ed47c5b50ce1d87b3b37ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 23]: /images/20220412/b4e204aab2174ebaa6fe5503a32b7ff0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 24]: /images/20220412/259b3272a0c1489ca4701bc5b4d2b74e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 25]: /images/20220412/b74940a027644f25b95fea4643e5488a.png
[20181201162625409.png]: /images/20220412/103fc836f5ed44ed879f998acba160e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 26]: /images/20220412/d4dcc902ff454887ad19a52980fba7ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 27]: /images/20220412/00e185e7c77347ba8d55b03157dda6a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 28]: /images/20220412/b62dea33286147c2866d3db4d47db9d4.png
[20181201162715196.png]: /images/20220412/748c2ab456ab4c2da2838c7cddbe7810.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 29]: /images/20220412/37b67967ad27469b8ac705fa0635653b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 30]: /images/20220412/af674cd792394d5783b74d5fa6dce1a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 31]: /images/20220412/d4fe7b3794474240b1ba2eb31bbada41.png
[System.in]: http://System.in