23_IO_第23天（字节流、字符流）_讲义

拼搏现实的明天。 2022-04-14 06:16 158阅读 0赞

第23天 IO流  
今日内容介绍  
 字节流  
 字符流  
01输入和输出  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]

* A:输入和输出
        * a: 参照物
            * 到底是输入还是输出，都是以Java程序为参照
        * b: Output
            * 把内存中的数据存储到持久化设备上这个动作称为输出（写）Output操作
            * 程序到文件称为输出
        * c: Input
            * 把持久设备上的数据读取到内存中的这个动作称为输入（读）Input操作
            * 文件到程序称为输入
        * d: IO操作
            * 把上面的这种输入和输出动作称为IO操作

02 字节输出流OutputStream  
OutputStream此抽象类，是表示输出字节流的所有类的超类。操作的数据都是字节，定义了输出字节流的基本共性功能方法。

* A: 字节输出流OutputStream
        * a.概念
            * IO流用来处理设备之间的数据传输
            * Java对数据的操作是通过流的方式
            * Java用于操作流的类都在IO包中
            * 流按流向分为两种：输入流，输出流。
            * 流按操作类型分为两种：
                * 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
                * 字符流 : 字符流只能操作纯字符数据，比较方便。
        * b.IO流常用父类
            * 字节流的抽象父类：
                * InputStream 
                * OutputStream
            * 字符流的抽象父类：
                * Reader 
                * Writer        
        * c.IO程序书写
            * 使用前，导入IO包中的类
            * 使用时，进行IO异常处理
            * 使用后，释放资源
        * d: 方法介绍
            *  void close(): 关闭此输出流并释放与此流有关的所有系统资源。
            *  void write(byte[] b)： 将 b.length 个字节从指定的 byte 数组写入此输出流
            *  void write(byte[] b, int off, int len) ：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
            * abstract  void write(int b) ： 将指定的字节写入此输出流。

03 字节输出流FileOutputStream写字节  
OutputStream有很多子类，其中子类FileOutputStream可用来写入数据到文件。  
FileOutputStream类，即文件输出流，是用于将数据写入 File的输出流。  
![在这里插入图片描述][20181126110826770.png]  
 构造方法  
![在这里插入图片描述][20181126110912277.png]

* A: 字节输出流FileOutputStream写字节
        * a: FileOutputStream
            * 写入数据文件,学习父类方法,使用子类对象
        * b: FileOutputStream构造方法
            * 作用：绑定输出的输出目的
            * FileOutputStream(File file) 
                * 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
            * FileOutputStream(File file, boolean append) 
                * 创建一个向指定 File 对象表示的文件中写入数据的文件输出流，以追加的方式写入。
            * FileOutputStream(String name) 
                * 创建一个向具有指定名称的文件中写入数据的输出文件流。
            * FileOutputStream(String name, boolean append) 
                * 创建一个向具有指定 name 的文件中写入数据的输出文件流，以追加的方式写入。
        * c: 流对象使用步骤
            *  1. 创建流子类的对象,绑定数据目的
            *  2. 调用流对象的方法write写
            *  3. close释放资源
        * d: 注意事项
            * 流对象的构造方法,可以创建文件,如果文件存在,直接覆盖

package cn.itcast.demo;
    /*
     * 字节输出流
     * 		java.io.OutputStream
     * 		作用：从Java程序,写出文件
     * 		字节：这样流每次只操作文件中的一个字节
     * 		写任意文件
     * 
     * 方法都是写入的方法：
     *  void write(byte[] b)  写入一个字节
     *  void write(byte[] b, int off, int len) 写入字节数组,int开始写入的索引,int写几个
     *  abstract  void write(int b)  写入字节数组 
     *  close()方法  关闭此输出流并释放与此流有关的所有系统资源
     *  
     *  流对象,操作文件的时候,自己不做,依赖操作系统
     *  
     * 此抽象类是表示输出字节流的所有类的超类
     * 输出流接受输出字节并将这些字节发送到某个接收器
     */
    public class OutputStreamDemo {
    
    }

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

package cn.itcast.demo;
    
    //import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * FilterOutputStream
     * 写入数据文件,学习父类方法,使用子类对象
     * 
     * 子类中的构造方法：作用：绑定输出的目的
     * 		参数：
     * 			File   封装文件
     * 			String 字符串的文件名
     * 			
     * 流对象使用步骤：
     * 		1.创建流子类的对象,绑定数据目的
     * 		2.调用流对象的方法write写
     * 		3.close释放资源
     * 
     * 该对象的构造方法,可以创建文件,如果文件存在,直接覆盖
     * 汉字占两个字节
     * 一个数字占一个字节
     * 一个英文字母占一个字节
     * 100 - 就占三个字节
     * 
     *  ASCII数字对应表
     * 	0~9数字对应十进制48－57
    	a~z字母对应的十进制97－122十六进制61－7A
    	A~Z字母对应的十进制65－90十六进制41－5A
     */
    public class FileOutputStreamDemo {
    	public static void main(String[] args) throws IOException{
    		FileOutputStream fos = new FileOutputStream("E:\\demo\\b.txt");
    		//流对象的方法write写入数据
    		//写1个字节
    		fos.write(100);//d
    		
    		//写入数字100
    		//fos.write(49);
    		//fos.write(48);
    		//fos.write(48);
    		
    		//写字节数组
    		//byte[] bytes = {-65,-66,-67,-68};//烤郊
    		byte[] bytes = {65,66,67,68};//ABCD
    		fos.write(bytes);
    		
    		//写字节数组的一部分
    		//void write(byte[] b, int off, int len)  开始索引,写几个
    		fos.write(bytes, 1, 2);
    		
    		//byte[] getBytes()  
    		//用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
    		//写入字节数组的简便方式
    		//写字符串
    		fos.write("hello".getBytes());
    		
    		//关闭资源
    		fos.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]  
04 给文件中续写和换行  
我们直接new FileOutputStream(file)这样创建对象，写入数据，会覆盖原有的文件，那么我们想在原有的文件中续写内容怎么办呢？  
继续查阅FileOutputStream的API。发现在FileOutputStream的构造函数中，可以接受一个boolean类型的值，如果值true，就会在文件末位继续添加。  
 构造方法  
![在这里插入图片描述][20181126154235828.png]  
 给文件中续写数据和换行，代码演示：

package cn.itcast.demo;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * FileOutputStream文件的读写和换行问题
     * 续写：FileOutputStream构造方法的第二个参数中,加入true
     * 在文件中,写入换行,符号换行\r\n     \r(回车符) \n(换行符)
     */
    public class FileOutputStreamDemo1 {
    	public static void main(String[] args) throws IOException {
    		File file = new File("E:\\b.txt");
    		FileOutputStream fos = new FileOutputStream(file,true);//连续跑两次得：hellohello
    		fos.write("hello\r\n".getBytes());//\r\n -- 换行符
    		fos.write("World".getBytes());
    		
    		fos.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]  
05 IO异常的处理  
在前面编写代码中都发生了IO的异常。我们在实际开发中，对异常时如何处理的，我们来演示一下。

* A: IO中的异常处理
        * a:IO流的异常处理
            * try catch finally
                            
        * b: 细节
            * 1. 保证流对象变量,作用域足够
            * 2. catch里面,怎么处理异常
                * 输出异常的信息,目的看到哪里出现了问题
                * 停下程序,从新尝试
            * 3. 如果流对象建立失败了,需要关闭资源吗
                * new 对象的时候,失败了,没有占用系统资源
                * 释放资源的时候,对流对象判断null
                * 变量不是null,对象建立成功,需要关闭资源

package cn.itcast.demo;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * IO流的异常处理
     * try catch finally
     * IO问题：我们只是提供哪里出现问题的信息,具体操作是人为外部处理
     * 细节：
     * 	1.保证流对象变量,作用域足够
     * 	2.catch里面,怎么处理异常
     * 		输出异常的信息,目的是看到哪里出现问题
     * 停下程序,重新处理
     * 	3.如果流对象建立失败,需要关闭资源嘛
     * 		new对象的时候,失败了,没有占用系统资源fos = new FileOutputStream("s:\\a.txt");
     * 		释放资源的时候,对流对象判断为null,不需要关闭资源
     * 		  			   对流对象判断不为null,需要关闭资源
     */
    public class FileOutputStreamDemo2 {
    	public static void main(String[] args) {
    		//try外面声明变量,try里面建立对象
    		FileOutputStream fos = null;
    		try {
    			fos = new FileOutputStream("E:\\a.txt");
    			fos.write(100);//d
    			不能写在try里面,因为如果捕获到异常后,fos.close()语句会无法执行,直接跳到catch里面
    			//但是必须关闭资源
    			//fos.close();		
    		} catch (IOException ex) {
    			//1.ex.printStackTrace();
    			//2.ex.getMessage()
    			//3.ex.toString()
    			System.out.println(ex.toString());//三种方法都可以
    			throw new RuntimeException("文件写入失败,重试");
    		}finally {
    			//Unhandled exception type IOException
    			//但是你会发现,你虽然解决了上面两个异常,但是close这里异常没有解决
    			//故还需解决这里的异常
    			try {	
    				//判断这个fos是否创建成功
    				if(fos != null){
    					fos.close();					
    				}
    			} catch (IOException ex) {
    				System.out.println(ex.toString());
    				throw new RuntimeException("关闭资源失败");
    			}
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]  
06 字节输入流InputStream  
通过前面的学习，我们可以把内存中的数据写出到文件中，那如何想把内存中的数据读到内存中，我们通过InputStream可以实现。InputStream此抽象类，是表示字节输入流的所有类的超类。，定义了字节输入流的基本共性功能方法。  
![在这里插入图片描述][20181126155130183.png]  
 int read():读取一个字节并返回，没有字节返回-1.  
 int read(byte\[\]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。

* A: 字节输入流InputStream
        * a: 方法介绍
            * abstract  int read() ：
                * 从输入流中读取数据的下一个字节。
            * int read(byte[] b)  
                * 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
            * int read(byte[] b, int off, int len) 
                * 将输入流中最多 len 个数据字节读入 byte 数组。
            * void close() 
                * 关闭此输入流并释放与该流关联的所有系统资源。

package cn.itcast.demo1;
    /*
     * 字节输入流：
     * 	java.io.InputStream 此抽象类是表示字节输入流的所有类的超类
     * 作用：读取输入文件,每次只读取1个字节
     * 读取的方法read
     * 	 
     * abstract  int read() 读取1个字节
     * int read(byte[] b)  从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。        
       int read(byte[] b, int off, int len) 
             将输入流中最多 len 个数据字节读入 byte 数组。 
    
     */
    public class InputStreamDemo {
    
    }

07 FileInputStream类  
InputStream有很多子类，其中子类FileInputStream可用来读取文件内容。  
FileInputStream 从文件系统中的某个文件中获得输入字节。  
![在这里插入图片描述][20181126155402771.png]  
 构造方法  
![在这里插入图片描述][20181126155427202.png]  
08 FileInputStream类读取数据read方法  
在读取文件中的数据时，调用read方法，实现从文件中读取数据  
![在这里插入图片描述][20181126155640252.png]  
 从文件中读取数据，代码演示：

package cn.itcast.demo1;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /*08
     * FileInputStream读取文件
     * 构造方法：为这个该对象绑定数据源
     * 参数：
     * 		File 类型对象
     * 		String 对象
     * 输入流读取文件的步骤：
     * 		1.创建字节输入流的子类对象
     * 		2.调用读取方法read读取
     * 		3.关闭资源
     *  int read() 从此输入流中读取一个数据字节 
     *  执行一次,就会自动读取下一个字节
     *  返回值
              
     */
    public class FileInputStreamDemo {
    	public static void main(String[] args) throws IOException {
    		FileInputStream fis = new FileInputStream("E:\\a.txt");
    		//读取一个字节,调用方法read 返回int
    		//使用循环方式读取文件,循环结束的条件是read()方法返回-1
    		int len = 0;//接收一下read方法的返回值
    		while((len = fis.read()) != -1){
    			System.out.print((char)len);
    		}
    
    		//关闭资源
    		fis.close();
    	}
    }
    /*
     * 一次一次读取 
    	int i = fis.read();
    	System.out.println((char)i);
    	
    	i = fis.read();
    	System.out.println((char)i);
    	
    	i = fis.read();
    	System.out.println((char)i);
    	
    	i = fis.read();
    	System.out.println(i);
    */

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]  
09 读取数据read(byte\[\])方法  
在读取文件中的数据时，调用read方法，每次只能读取一个，太麻烦了，于是我们可以定义数组作为临时的存储容器，这时可以调用重载的read方法，一次可以读取多个字符。  
![在这里插入图片描述][20181126155911750.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]

package cn.itcast.demo1;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /*
     * FileInputStream读取文件
     * 	读取方法： int read(byte[] b) 读取字节数组
     从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
     	数组作用:起到缓存作用,提高效率
     	read返回的int,表示什么意义:读取到多少个有效的字节数
     */
    public class FileInputStreamDemo1 {
    	public static void main(String[] args) throws IOException {
    		FileInputStream fis = new FileInputStream("e:\\a.txt");
    		//创建字节数组
    		byte[] b = new byte[2];
    		
    		int len = 0;
    		//while((len = fis.read(b)) != -1) 这里的len起缓存fis.read()结果作用
    		//String(byte[] bytes, int offset, int length) 
    		//bytes - 要解码为字符的 byte
    		//offset - 要解码的第一个 byte 的索引
    		//length - 要解码的 byte 数 
    		while((len = fis.read(b)) != -1){
    			//String(byte[] bytes) 
    			//通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String
    			//System.out.print(new String(b));//abcb
    			System.out.print(new String(b,0,len));//abc
    		}
    		
    				
    		fis.close();
    	}
    }
    /*
     * 
     * int len = fis.read(b);
    	//System.out.println(b);//打印地址 [B@95cfbe
    	//String(byte[] bytes) 
    	//通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String
    	System.out.println(new String(b));//ab
    	System.out.println(len);//2
    	
    	len = fis.read(b);
    	System.out.println(new String(b));//cb
    	System.out.println(len);//1
    	
    	len = fis.read(b);
    	System.out.println(new String(b));//cb
    	System.out.println(len);//-1
    */

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]  
字节流练习  
既然会了文件的读和写操作了，那么我们就要在这个基础上进行更为复杂的操作。使用读写操作完成文件的复制。  
文件复制原理  
10 字节流复制文件读取单个字节  
原理；读取一个已有的数据，并将这些读到的数据写入到另一个文件中。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]

package cn.itcast.demo2;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * 将数据源E:\\a.txt
     * 复制到F:\\a.txt	数据目的
     * 
     * 字节输入流,绑定数据源
     * 字节输出流,绑定数据目的
     * 
     * 输入,读取1个字节
     * 输出,写1个字节
     * 效率很差：因为是一个一个字节读取与写入
     */
    public class CopyFileDemo {
    	public static void main(String[] args) {
    		//定义两个流对象变量
    		FileInputStream fis = null;
    		FileOutputStream fos = null;
    		try{
    			//建立两个流的对象,绑定数据源和数据目的
    			//不成文规定：先开后关
    			fis = new FileInputStream("E:\\a.txt");
    			fos = new FileOutputStream("F:\\a.txt");
    			//字节输入流,读取1个字节,输出流写入1个字节
    			int len = 0;
    			while((len = fis.read()) != -1){
    				fos.write(len);
    			}
    		}catch(IOException ex){
    			System.out.println(ex);
    			throw new RuntimeException("文件复制失败");
    		}finally {
    			try {
    				if(fos != null){
    					fos.close();
    				}
    			} catch (IOException ex) {
    				throw new RuntimeException("释放资源失败");
    			}finally {
    				try {
    					if(fis != null){
    						fis.close();
    					}				
    				} catch (IOException ex) {
    					throw new RuntimeException("释放资源失败");
    				}
    			}
    		}
    	}
    }

缓冲数组方式复制文件  
11 字节流复制文件读取字节数组  
上述代码复制文件效率太低了，并且频繁的从文件读数据，和写数据，能不能一次多把文件中多个数据都读进内容中，然后在一次写出去，这样的速度一定会比前面代码速度快。

package cn.itcast.demo2;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * 字节流复制文件
     * 	采用数组缓存提高效率
     *  字节数组
     *  FileInputStream 	读取字节数组
     *  FileOutputStream	写入字节数组
     *   1KB表示1K个Byte,也就是1024个字节
     */
    public class CopyFileDemo1 {
    	public static void main(String[] args) {
    		long s = System.currentTimeMillis();
    		FileInputStream fis = null;
    		FileOutputStream fos = null;
    		try {
    			fis = new FileInputStream("E:\\a.doc");
    			fos = new FileOutputStream("F:\\a.doc");
    			//定义字节数组,缓冲
    			byte[] bytes = new byte[1024];//1KB表示1K个Byte,也就是1024个字节
    			//读取数组,写入数组
    			int len = 0;
    			while((len = fis.read(bytes)) != -1){
    				fos.write(bytes, 0, len);
    			}
    		} catch (IOException e) {
    			System.out.println(e);
    			throw new RuntimeException("文件复制失败");
    		}finally {
    			try {
    				if(fos != null){
    					fos.close();
    				}
    			} catch (IOException ex) {
    				throw new RuntimeException("释放资源失败");
    			}finally {
    				try {
    					if(fis != null){
    						fis.close();
    					}
    				} catch (IOException ex) {
    					throw new RuntimeException("释放资源失败");
    				}
    			}
    		}
    		long e = System.currentTimeMillis();
    		System.out.println(e-s);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]  
12 编码表

*  A: 编码表
    
     *  a: 定义：
        
         *  生活中字符和计算机二进制的对应关系表,就是编码表
     *  b: 分类
        
         *  1、ascii： 一个字节中的7位就可以表示。对应的字节都是正数。0-xxxxxxx
         *  2、iso-8859-1:拉丁码表 latin，用了一个字节用的8位。1-xxxxxxx 负数。
         *  3、GB2312:简体中文码表。包含6000-7000中文和符号。用两个字节表示。两个字节第
         *  一个字节是负数,第二个字节可能是正数
            
             *  GBK:目前最常用的中文码表，2万的中文和符号。用两个字节表示，其中的一部分文字，
             *  第一个字节开头是1，第二字节开头是0
             *  GB18030：最新的中文码表，目前还没有正式使用。
         *  4、unicode：国际标准码表:无论是什么文字，都用两个字节存储。
            
             *  Java中的char类型用的就是这个码表。char c = ‘a’;占两个字节。
             *  Java中的字符串是按照系统默认码表来解析的。简体中文版 字符串默认的码表是GBK。
         *  5、UTF-8:基于unicode，一个字节就可以存储数据，不要用两个字节存储，而且这个
         *  码表更加的标准化，在每一个字节头加入了编码信息(后期到api中查找)。
         *  6、能识别中文的码表：GBK、UTF-8；正因为识别中文码表不唯一，涉及到了编码解码问题。
            
             *  对于我们开发而言；常见的编码 GBK UTF-8 ISO-8859-1
             *  文字—>(数字) ：编码。 “abc”.getBytes() byte\[\]
             *  (数字)—>文字 : 解码。 byte\[\] b=\{97,98,99\} new String(b)

**文字—>(数字) ：编码。 “abc”.getBytes() byte\[\]  
(数字)—>文字 : 解码。 byte\[\] b=\{97,98,99\} new String(b)**  
13 字符输出流写文本FileWriter类

* A: 字符输出流写文本FileWriter类
        * a: 方法介绍
            *  void write(int c)
                *  写入单个字符
            * void write(String str)  
                * 写入字符串
            * void write(String str, int off, int len) 
                * 写入字符串的某一部分
            * void write(char[] cbuf)  
                * 写入字符数组
            * abstract  void write(char[] cbuf, int off, int len)  
                *  写入字符数组的某一部分

字符输出流Writer  
既然有专门用于读取字符的流对象，那么肯定也有写的字符流对象，查阅API，发现有一个Writer类，Writer是写入字符流的抽象类。其中描述了相应的写的动作。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]  
FileWriter类  
查阅FileOutputStream的API，发现FileOutputStream 用于写入诸如图像数据之类的原始字节的流。要写入字符流，请考虑使用 FileWriter。  
打开FileWriter的API介绍。用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。  
 构造方法  
![在这里插入图片描述][20181126161555350.png]  
FileWriter写入中文到文件中  
 **写入字符到文件中，先进行流的刷新，再进行流的关闭。**

package cn.itcast.demo3;
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /*
     * 字符输出流
     * 	  java.io.Writer 所有字符输出流的超类
     * 写文件,写文本文件
     * 
     * 写的方法write
     * 	void write(int c)  写入1个字符
     *  void write(char[] cbuf)   写字符数组
     *  abstract  void write(char[] cbuf, int off, int len) 写入字符串的某一部分,开始索引,写几个
     *  void write(String str)   写入字符串
     *  
     *  Writer类的子类对象FileWriter
     *  构造方法：写入的数据目的
     *  	File   类型对象
     *  	String 文件名
     *  
     *  字符输出流写数据的时候,必须要运行一个功能,刷新功能
     *  flush()
     */
    public class WriterDemo {
    	public static void main(String[] args) throws IOException {
    		FileWriter fw = new FileWriter("E:\\1.txt");
    		//写入1个字符
    		fw.write(100);
    		//刷新该流的缓冲
    		fw.flush();
    		
    		//写1个字符数组
    		char[] c = {'a','b','c'};
    		fw.write(c);
    		fw.flush();
    		
    		//写字符数组的一部分
    		fw.write(c,0,2);
    		fw.flush();//只要Writer才刷新
    		
    		//写入字符串
    		fw.write("String");
    		fw.flush();
    		
    		//关闭此流，但要先刷新它
    		fw.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]  
14 flush()和close()的区别？  
![在这里插入图片描述][20181126161757396.png]  
**flush():将流中的缓冲区缓冲的数据刷新到目的地中，刷新后，流还可以继续使用。  
close():关闭资源，但在关闭前会将缓冲区中的数据先刷新到目的地，否则丢失数据，然后在关闭流。流不可以使用。如果写入数据多，一定要一边写一边刷新，最后一次可以不刷新，由close完成刷新并关闭。**  
15 字符输入流读取文本FileReader类  
字符输入流Reader  
上述程序中我们读取拥有中文的文件时，使用的字节流在读取，那么我们读取到的都是一个一个字节。只要把这些字节去查阅对应的编码表，就能够得到与之对应的字符。API中是否给我们已经提供了读取相应字符的功能流对象，Reader，读取字符流的抽象超类。  
![在这里插入图片描述][20181126161904748.png]  
 read():读取单个字符并返回  
 read(char\[\]):将数据读取到数组中，并返回读取的个数。  
FileReader类  
查阅FileInputStream的API，发现FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。  
打开FileReader的API介绍。用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的  
 构造方法  
![在这里插入图片描述][20181126161940823.png]  
FileReader读取包含中文的文件  
 使用FileReader读取包含中文的文件

* A: 字符输入流读取文本FileReader类
        * a: 方法介绍
            *  int read() 
                * 读取单个字符
            * int read(char[] cbuf) 
                * 将字符读入数组
            * abstract  int read(char[] cbuf, int off, int len)  
                * 将字符读入数组的某一部分。

package cn.itcast.demo3;
    
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    
    /*
     * 字符输入流读取文本文件,所有字符输入流的超类
     * 		java.io.Reader
     * 专门读取文本文件
     * 
     * 读取的方法：read()
     *   int read() 读取1个字符
     *   int read(char[] cbuf) 读取字符数组  
     *   
     *   Reader类是抽象类,找到子类对象FileReader
     *   
     *   构造方法：
     *   	参数：File   类型对象		FileReader(File file) 
     *  		 String	文件名		FileReader(String fileName) 
    
     */
    public class ReaderDemo { 
    
    	public static void main(String[] args) throws IOException {
    		FileReader fr = new FileReader("E:\\a.txt");//读取文本文件
    		//int len = 0;
    		//while((len = fr.read()) != -1){
    			//System.out.print((char)len);
    		//}
    		//读取字符数组  
    		char[] ch = new char[1024];
    		int len1 = 0;
    		while((len1 = fr.read(ch)) != -1){
    			//String(byte[] bytes, int offset, int length) 
    			//bytes - 要解码为字符的 byte
    			//offset - 要解码的第一个 byte 的索引
    			//length - 要解码的 byte 数 
    			System.out.println(new String(ch,0,len1));
    		}
    		fr.close();
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]  
16 字符流复制文本文件  
字符流练习  
复制文本文件  
练习：复制文本文件。  
思路：  
1，既然是文本涉及编码表。需要用字符流。  
2，操作的是文件。涉及硬盘。  
3，有指定码表吗？没有，默认就行。  
操作的是文件，使用的 默认码表。使用哪个字符流对象。直接使用字符流操作文件的便捷类。FileReader FileWriter

package cn.itcast.demo2;
    
    import java.io.FileInputStream;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /*
     * 字符流复制文本文件,必须文本文件
     * 字符流查询本机默认的编码表,简称中文GBK
     * FileReader读取数据源
     * FileWriter写入到数据目的
     */
    public class CopyZiFuDemo {
    	public static void main(String[] args) {
    		long s = System.currentTimeMillis();
    		FileReader fr = null;
    		FileWriter fw = null;
    		try {
    			//字符流只能玩文本文件,不能玩别的
    			//fr = new FileReader("e:\\a.txt");
    			//fw = new FileWriter("f:\\a.txt");
    			//会发现程序不报错,但是复制过去的jpg文件明显没有之前的大,而且打不开
    			fr = new FileReader("e:\\a.jpg");
    			fw = new FileWriter("f:\\a.jpg");
    			char[] cbuf = new char[1024];//char占两个字节   2个KB
    			int len = 0;
    			while((len = fr.read(cbuf)) != -1){
    				fw.write(cbuf, 0, len);
    				fw.flush();//需要刷新
    			}
    		} catch (IOException ex) {
    			System.out.println(ex);
    			throw new RuntimeException("文件复制失败");
    		}finally {
    			try {
    				if(fw != null){
    					fw.close();
    				}
    			} catch (IOException ex) {
    				throw new RuntimeException("释放资源失败");
    			}finally {
    				try {
    					if(fr != null){
    						fr.close();
    					}
    				} catch (IOException ex) {
    					throw new RuntimeException("释放资源失败");
    				}
    			}
    		}
    		long e = System.currentTimeMillis();
    		System.out.println(e-s);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 17]  
17 总结  
知识点总结  
 IO流的分类  
|- 字节流  
|- 字节输入流 InputStream 抽象类  
|- FileInputStream 操作文件的字节输入流  
|- 字节输出流 OuputStream抽象类  
|- FileOutputStream 操作文件的字节输出流  
|- 字符流  
|- 字符输入流 Reader抽象类  
|- InputStreamReader 输入操作的转换流  
|- FileReader 用来操作文件的字符输入流（简便的流）  
|- 字符输出流 Writer抽象类  
|- OutputStreamWriter 输出操作的转换流  
|- FileWriter 用来操作文件的字符输出流（简便的流）

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20220414/56aadcdf5f5148d2a8faaf224974cca9.png
[20181126110826770.png]: /images/20220414/56d27468b3e44d13ba6c956e77618171.png
[20181126110912277.png]: /images/20220414/47ae4c6881ca4430a48a85b8078f9122.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20220414/05d6a6908c5a49c2bb65c6e367d3daf9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20220414/394bb5fbf021411c9441f272e6f34953.png
[20181126154235828.png]: /images/20220414/030568fcfdf94b0085da682184a3f756.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20220414/31e143ff09b54e4ea092be5dbd66bd46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20220414/9bd66685f5764e4fb3b9e2bfe5e9e4ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20220414/e2febd7c82b04398a72b7826d86d8b10.png
[20181126155130183.png]: /images/20220414/c7416e2b9ceb4c8aa7aa81df73874a22.png
[20181126155402771.png]: /images/20220414/25a40bc34b1e49ebb5d45f8a84d4b18e.png
[20181126155427202.png]: /images/20220414/11ce3b8d60514e62bc4e31f3b0d8065b.png
[20181126155640252.png]: /images/20220414/4f30ce52c36d4cc7bd6e96416c9fc0b5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20220414/aecb6ecf895d4ea0bfb44af5a35555b3.png
[20181126155911750.png]: /images/20220414/e29d7033c6854b7d9b189631736a647c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20220414/a9502d3c62d040198f4d2b5839ec050c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20220414/5f99a29ad6ea4fabb65f4fb3cf07c86a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]: /images/20220414/9f6c7d047bbb4372bc9be4b00c7d30db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]: /images/20220414/c99f7534f64743008ca8afd628f61df2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]: /images/20220414/d501401174304817ab79950fde2e577e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]: /images/20220414/eed2b937b75a49d7a959f06d3e8bbaac.png
[20181126161555350.png]: /images/20220414/8b6c608f34aa4f89981f39ba72e6af4f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]: /images/20220414/0c15dd63f1744b47ac55f3584ccb261f.png
[20181126161757396.png]: /images/20220414/4750b4262d1541779a9dc2fb95f8846d.png
[20181126161904748.png]: /images/20220414/68f9b4acfda34158a9d6544b2b3f925d.png
[20181126161940823.png]: /images/20220414/2b0b462f93044bbb8aecb02381427ce4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]: /images/20220414/60872d9bc3714e3d9073fda4795ddd6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]: /images/20220414/23b2fad538ba4bc6834ea7c1d91b41a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]: /images/20220414/1b2e78105b744ca199917c9d3a567618.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 17]: /images/20220414/2c0d3251fcce45a5835545bbf791b803.png