缓冲流+转换流+序列化流+打印流

一.缓冲流

1. 比如能够高效读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等。这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。

1.1 概述

1. 缓冲流,也叫高效流，是对4个基本的 FileXxx 流的增强，所以也是4个流，按照数据类型分类：
   • 字节缓冲流： BufferedInputStream ， BufferedOutputStream
   • 字符缓冲流： BufferedReader ， BufferedWriter
2. 缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

1.2 字节缓冲流

1. java.io.BufferedOutputStream extends OutputStream

   • BufferedOutputStream:字节缓冲输出流
   • 继续自父类OutputStream中的成员方法:
     • void write(int b) 写一个字节
     • void write(byte[] b) 写一个字节数组
     • void write(byte[] b, int off, int len) 写字节数组的一部分,off数组的开始索引,len是字节个数
     • void flush() 刷新此输出流并强制写出所有缓冲的输出字节。
     • void close() 关闭此输出流并释放与此流有关的所有系统资源。

2. java.io.BufferedInputStream extends InputStream

   • BufferedInputStream:字节缓冲输入流
   • 继续自父类InputStream中的成员方法:
     • public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
     • public abstract int read()： 读取一个字节,并返回
     • public int read(byte[] b)： 读取多个字节,存储到数组中返回

3. 字节缓冲流图解:
   

1.2.1 构造方法

1. public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。

   • 参数:

     • InputStream in:字节输入流
       • 我们可以传递FileInputStream,BufferedInputStream就会给FileInputStream增加一个缓冲区,提高FileInputStream读取的效率
     • int size:指定缓冲区的大小(数组的大小)

   • 字节缓冲输入流的使用步骤(重点):

     • 创建BufferedInputStream对象,构造方法中传递FileInputStream对象
     • 使用BufferedInputStream对象read,读取文件
     • 释放资源 close();

   • 构造举例，代码如下：

     public static void main(String[] args) throws IOException {
             //1.创建BufferedInputStream对象,构造方法中传递FileInputStream对象
             BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day10\\bu.txt"));
             //2.使用BufferedInputStream对象read,读取文件
             //public int read(byte[] b)： 读取多个字节,存储到数组中返回
             byte[] bytes = new byte[1024];
             int len = 0;
             while((len = bis.read(bytes))!=-1){
                 System.out.println(new String(bytes,0,len));
             }
             //3.释放资源
             bis.close();
         }
     

2. public BufferedOutputStream(OutputStream out) ： 创建一个新的缓冲输出流。

   • 参数:
     • OutputStream out:字节输出流
       • 我们可以传递FileInputStream,BufferedInputStream就会给FileInputStream增加一个缓冲区,提高FileOutputStream写入数据的效率
     • int size:指定缓冲区的大小
     • 字节缓冲输出流的使用步骤(重点):
       • 创建字节缓冲输出流BufferedOutputStream对象,构造方法中传递FileOutputStream对象
       • 使用BufferedOutputStream对象中的方法write,把数据写入到内存缓冲区中
       • 使用BufferedOutputStream对象中的方法flush,把内存缓冲区中的数据刷新到文件中
       • 释放资源 close();

• 构造举例,代码如下：

     public static void main(String[] args) throws IOException {
     //1.创建字节缓冲输出流BufferedOutputStream对象,构造方法中传递FileOutputStream对象
     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day10\\bu.txt"));
        //2.使用BufferedOutputStream对象中的方法write,把数据写入到内存缓冲区中
             bos.write("我是把数据写入到缓冲区中".getBytes());
          //3.使用BufferedOutputStream对象中的方法flush,把内存缓冲区中的数据刷新到文件中
             bos.flush();
             //4.释放资源
             bos.close();
         }
  

1.2.2 效率测试

1. 查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（375MB），测试它的效率。

   • 基本流，代码如下：

     public class BufferedDemo {
         public static void main(String[] args) throws FileNotFoundException {
             // 记录开始时间
            long start = System.currentTimeMillis();  
     // 创建流对象        
             try (
              FileInputStream fis = new FileInputStream("jdk8.exe");    
              FileOutputStream fos = new FileOutputStream("copy.exe")    
             ){
              // 读写数据    
                 int b;
                 while ((b = fis.read()) != ‐1) {
                     fos.write(b);
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
     // 记录结束时间        
             long end = System.currentTimeMillis();
             System.out.println("普通流复制时间:"+(end ‐ start)+" 毫秒");
         }
     }
     十几分钟过去了...
     

   • 缓冲流，代码如下：

     public class BufferedDemo {
         public static void main(String[] args) throws FileNotFoundException {
             // 记录开始时间
            long start = System.currentTimeMillis();  
     // 创建流对象        
             try (
     BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk8.exe"));    
     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));    
             ){
             // 读写数据
                 int b;
                 while ((b = bis.read()) != ‐1) {
                     bos.write(b);
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
     // 记录结束时间        
             long end = System.currentTimeMillis();
             System.out.println("缓冲流复制时间:"+(end ‐ start)+" 毫秒");
         }
     }
     缓冲流复制时间:8016 毫秒
     

   • 使用数组的方式，代码如下：

     public class BufferedDemo {
         public static void main(String[] args) throws FileNotFoundException {
            // 记录开始时间  
             long start = System.currentTimeMillis();
     // 创建流对象        
          try (
     BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk8.exe"));            
     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));        
             ){
                // 读写数据  
                 int len;
                 byte[] bytes = new byte[8*1024];
                 while ((len = bis.read(bytes)) != ‐1) {
                     bos.write(bytes, 0 , len);
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
     // 记录结束时间        
             long end = System.currentTimeMillis();
             System.out.println("缓冲流使用数组复制时间:"+(end ‐ start)+" 毫秒");
         }
     }
     缓冲流使用数组复制时间:666 毫秒
     

1.3 字符缓冲流

1. java.io.BufferedWriter extends Writer:字符缓冲输出流
   • 继承自父类Writer的共性成员方法:
     • public abstract void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
     • public abstract void flush() ：刷新此输出流并强制任何缓冲的输出字符被写出。
     • public void write(int c) ：写出一个字符。
     • public void write(char[] cbuf)：将 b.length字符从指定的字符数组写出此输出流。
     • public abstract void write(char[] b, int off, int len) :从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。
     • public void write(String str) ：写出一个字符串。
     • void write(String str, int off, int len) 写入字符串的某一部分。
2. java.io.BufferedReader extends Reader:字符缓冲输入流
   • 继承自父类Reader的共性成员方法:
     • public void close():关闭此流并释放与此流相关联的任何系统资源。
     • public int read():一次读取一个字符,并返回;读取到文件结尾返回-1
     • public int read(char[] cbuf):一次读取多个字符,存储到数组中,返回的是每次读取的有效字符个数

1.3.1 构造方法

1. public BufferedReader(Reader in) ：创建一个新的缓冲输入流。

   • 参数:

     • Reader in:字符输入流
       • 我们可以传递FileReader,BufferedReader会给FileReader增加一个缓冲区,提高FileReader读取数据的效率
     • int sz:手动指定缓冲区的大小

   • 使用步骤(重点):

     • 创建字符缓冲输入流BufferedReader对象,构造方法中传递FileReader对象
     • 使用BufferedReader对象中的方法read/readLine,读取文件
     • 释放资源

   • 代码实例:

     public static void main(String[] args) throws IOException {
             //System.out.println();//newLine();调用的就是newLine方法
             //1.创建字符缓冲输出流BufferedWriter对象,构造方法中传递FileWriter对象
       BufferedWriter bw = new BufferedWriter(new FileWriter("day11\\1.txt"));
             //2.使用BufferedWriter对象中的方法write,把数据写内存缓冲区中
             for (int i = 1; i <=10 ; i++) {
                 bw.write("你好"+i);
                 //bw.write("\r\n");
                 bw.newLine();
             }
             //3.释放资源(会调用flush,把内存缓冲区中的数据刷新到文件中)
             bw.close();
         }
     

2. public BufferedWriter(Writer out) ： 创建一个新的缓冲输出流。

   • 参数:

     • Writer out:字符输出流
       • 我们可以传递FileWriter,BufferedWriter就会给FileWriter增加一个缓冲区,提高FileWriter写数据的效率
     • int sz:手动指定缓冲区的大小

   • 使用步骤(重点):

     • 创建字符缓冲输出流BufferedWriter对象,构造方法中传递FileWriter对象
     • 使用BufferedWriter对象中的方法write,把数据写内存缓冲区中
     • 释放资源(会调用flush,把内存缓冲区中的数据刷新到文件中)

   • 代码实例:

     public static void main(String[] args) throws IOException {
             //1.创建字符缓冲输入流BufferedReader对象,构造方法中传递FileReader对象
       BufferedReader br = new BufferedReader(new FileReader("day11\\1.txt"));
             //2.使用BufferedReader对象中的方法read/readLine,读取文件
             /*
                 返现读取每行文本是一个重复的过程,所以可以使用循环优化
                 不知道文件中有多少行数据,所以使用while循环
                 while循环结束的条件,readLine方法读取到null
              */
             String line;
             while((line = br.readLine())!=null){
                 System.out.println(line);
             }
             //3.释放资源
             br.close();
         }
     

1.3.2 特有方法

1. 字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。
   • BufferedReader： public String readLine() : 读一行文字。
     • 通过下列字符之一即可认为某行已终止:换行 (’\n’)、回车 (’\r’) 或回车后直接跟着换行(\r\n)。
     • 返回:包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null
   • BufferedWriter： public void newLine() : 写一行行分隔符,由系统属性定义符号。
     • windows系统: \r\n
     • linux系统: /n
     • mac系统: /r

1.4 练习:文本排序

1. 请将文本信息恢复顺序:(文件名为in.txt)

   3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
   8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
   4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
   2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
   1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
   9.今当远离，临表涕零，不知所言。
   6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
   7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
   5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。
   

1.4.1 案例分析

1. 创建Map集合,key和value都是用String
2. 创建BufferedReader对象,构造方法中传递FileReader对象
3. 创建BufferedWriter对象,构造方法中传递FileWriter对象
4. 使用BufferedReader对象readLine,以行的方式读取文本
5. 对读取的每行文本进行切割,把序号和文本内容存储到一个String数组
6. 把序号和文本内容存储到Map集合中(key会进自然排序)
7. 遍历Map集合,获取每一个对健值
8. 使用BufferedWriter对象中的方法write,把键值对拼接在一起写在内存缓冲区中
9. 写换行
10. 释放字符

1.4.2 案例实现

public static void main(String[] args) throws IOException {
        //1.创建Map集合,key和value都是用String
        Map<String,String> map = new HashMap<>();
        //2.创建BufferedReader对象,构造方法中传递FileReader对象
        BufferedReader br = new BufferedReader(new FileReader("day11\\in.txt"));
        //3.创建BufferedWriter对象,构造方法中传递FileWriter对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("day11\\out.txt"));
        //4.使用BufferedReader对象readLine,以行的方式读取文本
        String line;
        while((line = br.readLine())!=null){
            //5.对读取的每行文本进行切割,把序号和文本内容存储到一个String数组
            String[] arr = line.split("\\.");
            //6.把序号和文本内容存储到Map集合中(key会进自然排序)
            map.put(arr[0],arr[1]);
        }
        //System.out.println(map);
        //7.遍历Map集合,获取每一个对健值
        Set<Map.Entry<String, String>> set = map.entrySet();
        for (Map.Entry<String, String> entry : set) {
            String key = entry.getKey();
            String value = entry.getValue();
            //8.使用BufferedWriter对象中的方法write,把键值对拼接在一起写在内存缓冲区中
            bw.write(key+"."+value);
            //9.写换行
            bw.newLine();
        }
        //10.释放字符
        bw.close();
        br.close();
    }

二.转换流

2.1 字符编码和字符集

2.1.1 字符编码

1. 字符编码
   计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本f符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。
   • 字符编码 Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

2.1.2 字符集

1. 字符集 Charset :也叫编码表。是一个系统支持的所有字符的集合,包括各国家文字、标点符号、图形符号、数字等。

2. 计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。
   

3. 可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

   • ASCII字符集 ：
     • ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。
     • 基本的ASCII字符集，使用7位（bits）表示一个字符，共128字符。ASCII的扩展字符集使用8位（bits）表示一个字符，共256字符，方便支持欧洲常用字符。
   • ISO-8859-1字符集：
     • 拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。
     • ISO-5559-1使用单字节编码，兼容ASCII编码。
   • GBxxx字符集：
     • GB就是国标的意思，是为了显示中文而设计的一套字符集。
     • GB2312：简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时,就表示一个汉字,这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母,日文的假名们都编进去了,连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码,这就是常说的"全角"字符,而原来在127号以下的那些就叫"半角"字符了
     • GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。
     • GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。
   • Unicode字符集 ：
     • Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。
     • 它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。
     • UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：
       • 128个US-ASCII字符，只需一个字节编码。
       • 拉丁文等字符，需要二个字节编码。
       • 大部分常用字（含中文），使用三个字节编码。
       • 其他极少使用的Unicode辅助字符，使用四字节编码。

2.2 编码引出的问题

1. 在IDEA中，使用 FileReader 读取项目中的文本文件。由于IDEA的设置，都是默认的 UTF-8 编码，所以没有任何问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

   public class ReaderDemo {
       public static void main(String[] args) throws IOException {
           FileReader fileReader = new FileReader("E:\\File_GBK.txt");
           int read;
           while ((read = fileReader.read()) != ‐1) {
               System.out.print((char)read);
           }
           fileReader.close();
       }
   }
   输出结果：
   ���
   

2. 那么如何读取GBK编码的文件呢？

2.3 InputStreamReader类

1. 转换流 java.io.InputStreamReader ，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。
2. java.io.InputStreamReader extends Reader:字符转换输入流
   • 作用:
     • 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。
     • 字节->字符:解码
   • 继承自父类Reader的共性成员方法:
     • public void close() ：关闭此流并释放与此流相关联的任何系统资源。
     • public int read()： 一次读取一个字符,并返回;读取到文件结尾返回-1
     • public int read(char[] cbuf):一次读取多个字符,存储到数组中,返回的是每次读取的有效字符个数

2.3.1 构造方法

1. InputStreamReader(InputStream in) : 创建一个使用默认字符集的字符流。

2. InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。

   • 参数:

     • InputStream in:字节输入流,读取文件中保存的字节
     • String charsetName:指定的编码表名称,不区分大小写,GBK/gbk,…UTF-8/utf-8/utf8;不写默认使用IDE的编码(UTF-8)

   • 使用步骤:

     • 创建InputStreamReader字符转换输入流对象,构造方法绑定字节输入流和指定的编码表名称
     • 使用InputStreamReader对象中的方法read,读取文件
     • 释放资源

   • 注意:
     构造方法中指定的编码表名称必须和文件的编码相同,否则会发生乱码

2.3.2 指定编码读取

1. 代码实例:

   public static void main(String[] args) throws Exception {
           read_utf8();
           read_gbk();
       }
       /*使用InputStreamReader字符转换输入流读取UTF-8编码格式的文件*/
       private static void read_gbk() throws Exception {
           //1.创建InputStreamReader字符转换输入流对象,构造方法中绑定字节输入流和指定的编码表名称
           InputStreamReader isr = new InputStreamReader(new FileInputStream("day11\\gbk.txt"),"GBK");
           //2.使用InputStreamReader对象中的方法read,读取文件
           int len = 0;
           while((len = isr.read())!=-1){
               System.out.println((char)len);
           }
           //3.释放资源
           isr.close();
       }
       /*使用InputStreamReader字符转换输入流读取UTF-8编码格式的文件*/
       private static void read_utf8() throws Exception {
           //1.创建InputStreamReader字符转换输入流对象,构造方法中绑定字节输入流和指定的编码表名称
           InputStreamReader isr = new InputStreamReader(new FileInputStream("day11\\utf8.txt"),"utf-8");
           //2.使用InputStreamReader对象中的方法read,读取文件
           int len = 0;
           while((len = isr.read())!=-1){
               System.out.println((char)len);
           }
           //3.释放资源
           isr.close();
       }
   

2.4 OutputStreamWriter类

1. java.io.OutputStreamWriter extends Writer:字符转换输出流
   • 作用:
     • 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。
     • 字符->字节:编码
2. 继承自父类Writer的共性成员方法:
   • public abstract void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
   • public abstract void flush() ：刷新此输出流并强制任何缓冲的输出字符被写出。
   • public void write(int c) ：写出一个字符。
   • public void write(char[] cbuf)：将 b.length字符从指定的字符数组写出此输出流。
   • public abstract void write(char[] b, int off, int len) ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。
   • public void write(String str) ：写出一个字符串。
   • public void write(String str, int off, int len) 写入字符串的某一部分。

2.4.1 构造方法

1. OutputStreamWriter(OutputStream in) : 创建一个使用默认字符集的字符流。

2. OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流。

   • 参数:

     • OutputStream out:字节输出流,把转换流转换之后的字节写入到文件中
     • String charsetName:指定的编码表名称,不区分大小写,GBK/gbk,…UTF-8/utf-8/utf8;不写默认使用IDE的编码(UTF-8)

   • 使用步骤:

     • 创建字符转换输出流OutputStreamWriter对象,构造方法中绑定字节输入流对象和指定的编码表名称
     • 使用OutputStreamWriter对象中的方法write,把数据写入到内存缓冲区中(字符->字节:编码)
     • 使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的数据,刷新到文件中(使用字节流写字节的过程)
     • 释放资源

2.4.2 指定编码写出

1. 代码实例:

   public static void main(String[] args) throws Exception {
           write_utf8();
           write_gbk();
       }
       /*使用字符转换输出流OutputStreamWriter写一个UTF-8编码格式的文件*/
       private static void write_gbk() throws Exception {
   //1.创建字符转换输出流OutputStreamWriter对象,构造方法中绑定字节输入流对象和指定的编码表名称
           OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day11\\gbk.txt"),"GBK");
   //2.使用OutputStreamWriter对象中的方法write,把数据写入到内存缓冲区中(字符->字节:编码)
           osw.write("你好");
           //3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的数据,刷新到文件中
           osw.flush();
           //4.释放资源
           osw.close();
       }
       /*使用字符转换输出流OutputStreamWriter写一个UTF-8编码格式的文件*/
       private static void write_utf8() throws Exception {
   //1.创建字符转换输出流OutputStreamWriter对象,构造方法中绑定字节输入流对象和指定的编码表名称
           //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day11\\utf8.txt"),"UTF-8");
           OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day11\\utf8.txt"));//不写默认使用编辑工具的编码
   //2.使用OutputStreamWriter对象中的方法write,把数据写入到内存缓冲区中(字符->字节:编码)
           osw.write("你好");
           //3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的数据,刷新到文件中
           osw.flush();
           //4.释放资源
           osw.close();
       }
   

2.4.3 转换流理解图解

2.5 练习：转换文件编码

1. 将GBK编码的文本文件，转换为UTF-8编码的文本文件。

2.5.1 案例分析

1. 案例分析

• 指定GBK编码的转换流，读取文本文件。
  • 用UTF-8编码的转换流，写出文本文件。

2. 什么时候使用便捷的字符流:操作文件的编码固定就是编辑工具的的默认编码
   • FileReader
   • FileWriter
   • 使用起来简单:不用传递编码表,不用创建字节流
3. 什么时候使用转换字符流 :操作文件的编码不是编辑工具的默认编码
   • InputStreamReader
   • OutputStreamWriter

2.5.2 案例实现

1. 代码实现:

   public static void main(String[] args) throws IOException {
    //创建字符转换输入流InputStreamReader对象,构造方法中绑定字节输入流对象和指定的编码表名称
           InputStreamReader isr = new InputStreamReader(new FileInputStream("day11\\我是GBK编码格式的文件.txt"),"GBK");
           //创建字符转换输出流OutputStream对象,构造方法中绑定字节输出流和指定的编码表名称
           //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day11\\我是UTF8编码格式的文件.txt"),"UTF-8");
           FileWriter osw = new FileWriter("day11\\我是UTF8编码格式的文件.txt");
           //使用InputStreamReader对象中的方法read读取文件
           char[] chars = new char[1024];
           int len = 0;
           while((len = isr.read(chars))!=-1){
               //使用OutputStreamWriter对象中的方法write,把读取到的字符写入到内存缓冲区中
               osw.write(chars,0,len);
           }
           //释放资源
           osw.close();
           isr.close();
       }
   

三.序列化

3.1 概述

1. Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该 对象的数据 、 对象的类型 和 对象中存储的属性 等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

2. 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。 对象的数据 、 对象的类型 和 对象中存储的数据 信息，都可以用来在内存中创建对象。看图理解序列化：
   

3. 创建一个Person类作为对象传递:

   • 进行序列化和反序列化的时候会抛出NotSerializableException:没有序列化异常类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。

     • Serializable接口也叫标记型接口
       • 当序列化反序列化的类实现了Serializable接口,那么就相当于给类添加了一个标记
       • 当我们继续序列化和反序列化的时候,会检查类上是否有这个标记
         • 有:可以序列化或者反序列化
         • 没有:就会抛出NotSerializableException

   • static:静态关键字

     • private static int age;
     • oos.writeObject(new Person(“张三”,18));
     • Object o = ois.readObject(); Person{name=‘张三’, age=0}
     • 静态优先于非静态加载到内存
     • 静态的成员变量属于类,不属于某个对象,被所有的对象所共享
     • 而我们序列化的是对象,所以静态的成员变量不能被序列化

   • transient:瞬态关键字

     • 作用:阻止成员变量序列化
     • private transient int age;
     • oos.writeObject(new Person(“张三”,18));
     • Object o = ois.readObject(); Person{name=‘张三’, age=0}

   • 代码实例:

     public class Person implements Serializable{
         /*为了防止序列号冲突异常InvalidClassException
             可以手动添加一个序列号
             要求:private static final long serialVersionUID = 任意值L;
             常量是不能改变的,无论类的定义如何修改,序列号都不会改变
          */
         private static final long serialVersionUID = 1L;
         private String name;
         private static int age;
         private transient int age;
         public int age;
         public Person() {
         public Person(String name, int age) {this.name = name;this.age = age;}
         @Override
         public String toString() {
             return "Person{" +
                     "name='" + name + '\'' +
                     ", age=" + age +
                     '}';
         }
         public String getName() {return name;}
         public void setName(String name) {this.name = name;}
         public int getAge() {return age;}
         public void setAge(int age) {this.age = age;}
     }
     
     

3.2 ObjectOutputStream类

1. java.io.ObjectOutputStream extends OutputStream
   • 将Java对象的原始数据类型写出到文件,实现对象的持久存储。
   • 对象的序列化流:把对象以流的方式写入到文件中保存

3.2.1 构造方法

1. public ObjectOutputStream(OutputStream out) :创建一个指定OutputStream的ObjectOutputStream。

   • 参数:

     • OutputStream out:字节输出流

   • 特有的成员方法:

     • void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

   • 使用步骤:

     • 创建ObjectOutputStream对象,构造方法中传递字节输出流对象
     • 使用ObjectOutputStream对象中的方法writeObjet,把对象写入到文件中
     • 释放资源

   • 代码示例:

     public static void main(String[] args) throws IOException {
             //1.创建ObjectOutputStream对象,构造方法中传递字节输出流对象
     	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day11\\person.txt"));
             //2.使用ObjectOutputStream对象中的方法writeObjet,把对象写入到文件中
             oos.writeObject(new Person("小美女",18));
             //3.释放资源
             oos.close();
         }
     

3.2.2 序列化操作

1. 一个对象要想序列化，必须满足两个条件:
   • 该类必须实现 java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 NotSerializableException 。
   • 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

3.3 ObjectInputStream类

1. ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

2. java.io.ObjectInputStream extends InputStream,对象的反序列化流:把文件中保存的对象以流的方式读取出来

3.3.1 构造方法

1. public ObjectInputStream(InputStream in) ： 创建一个指定InputStream的ObjectInputStream。

   • 使用步骤:

     • 创建ObjectInputStream对象,构造方法中传递字节输入流
     • 使用ObjectInputStream对象中的方法readObject,读取文件中保存的对象
     • 释放资源

   • 注意:

     • public final Object readObject() throws IOException, ClassNotFoundException
     • readObejct方法声明了两个异常
     • ClassNotFoundException:class文件找不到异常
     • 反序列化有两个前提:
       • 被反序列化的类必须实现Serializable
       • 被反序列化的类必须有.class文件(Person.class)

   • 代码实例:

      public static void main(String[] args) throws IOException, ClassNotFoundException {
             //1.创建ObjectInputStream对象,构造方法中传递字节输入流
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day11\\person.txt"));
             //2.使用ObjectInputStream对象中的方法readObject,读取文件中保存的对象
             Object o = ois.readObject();
             System.out.println(o);
             //3.释放资源
             ois.close();
         }
     

3.3.2 反序列化操作1

1. 如果能找到一个对象的class文件,我们可以进行反序列化操作,调用ObjectInputStream读取对象的方法：

   public final Object readObject () : 读取一个对象。
   

2. 对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个ClassNotFoundException 异常。

3. 代码实例:

   public static void main(String[] args) throws IOException,ClassNotFoundException{
           //1.创建ObjectOutputStream对象,构造方法中传递字节输出流对象
           ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day11\\person2.txt"));
           //2.使用ObjectOutputStream对象中的方法writeObjet,把对象写入到文件中
           oos.writeObject(new Person("小美女1",18));
           oos.writeObject(new Person("小美女2",18));
           oos.writeObject(new Person("小美女3",18));
           //3.释放资源
           oos.close();
       }
   

3.3.3 反序列化操作2

1. 另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个 InvalidClassException 异常。 发生这个异常的原因如下：

   • 该类的序列版本号与从流中读取的类描述符的版本号不匹配
   • 该类包含未知数据类型
   • 该类没有可访问的无参数构造方法

2. Serializable 接口给需要序列化的类，提供了一个序列版本号。 serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

3. 代码实例:

   public static void main(String[] args) throws IOException,ClassNotFoundException{
           //1.创建ObjectInputStream对象,构造方法中传递字节输入流
           ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day11\\person2.txt"));
           //2.使用ObjectInputStream对象中的方法readObject,读取文件中保存的对象
           Object o = ois.readObject();
           System.out.println(o);
           o = ois.readObject();
           System.out.println(o);
           o = ois.readObject();
           System.out.println(o);
           o = ois.readObject();
   System.out.println(o);//EOFException 当输入过程中意外到达文件或流的末尾时，抛出此异常。
           //3.释放资源
           ois.close();
       }
   

4. 序列号冲突异常的原理和解决图解:
   

3.4 练习：序列化集合

1. 将存有多个自定义对象的集合序列化操作，保存到 list.txt 文件中。
2. 反序列化 list.txt ，并遍历集合，打印对象信息。

3.4.1 案例分析

1. 练习:序列化集合
   • 想要实现序列化多个对象,反序列化多个对象
   • 我们可以把对个对象存储到一个集合中
   • 对集合进行序列化和反序列化(集合也是一个对象)

3.4.2 案例实现

1. 代码实例:

    public static void main(String[] args) throws IOException, ClassNotFoundException {
           //创建一个ArrayList集合对象,保存多个Person对象
           ArrayList<Person> list = new ArrayList<>();
           list.add(new Person("张三1",18));
           list.add(new Person("张三2",18));
           list.add(new Person("张三3",18));
           list.add(new Person("张三4",18));
           //创建一个序列化的流ObjectOutputStream对象
           ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day11\\list.txt")) ;
           //使用ObjectOutputStream对象writeObject写对象
           oos.writeObject(list);
           //释放资源
           oos.close();
           //创建一个反序列化流ObjectInputStream对象
           ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day11\\list.txt"));
           //使用ObjectInputStream对象中的方法readObject,读取文件中保存的对象
           Object o = ois.readObject();
           //把Object强制为ArrayList集合
           ArrayList<Person> list2 = (ArrayList<Person>)o;
           //遍历集合
           for (Person p : list2) {
               System.out.println(p);
           }
       }
   

四.打印流

4.1 概述

1. 平时我们在控制台打印输出，是调用 print 方法和 println 方法完成的，这两个方法都来自于
   java.io.PrintStream 类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。
2. java.io.PrintStream extends OutputStream:打印流
   • 打印流的特点:
     • 为其他输出流添加了功能(print方法,println方法),使它们方便地打印各种数据值表示形式。
     • 与其他输出流不同，PrintStream 永远不会抛出 IOException,可能会抛出文件找不到异常
     • 不能读取文件,只能写(输出)

4.2 PrintStream类

1. 继承自父类OutputStream的共性成员方法:打开文件查看数据的时候会查询编码表
   • void write(int b) 写一个字节
   • void write(byte[] b) 写一个字节数组
   • void write(byte[] b, int off, int len) 写字节数组的一部分,off数组的开始索引,len写的字节个数
   • void flush() 刷新此输出流并强制写出所有缓冲的输出字节。
   • void close() 关闭此输出流并释放与此流有关的所有系统资源。

4.2.1 构造方法

1. PrintStream(File file) 输出的目的地是一个文件

2. PrintStream(OutputStream out) 输出的目的地是一个字节输出流

3. PrintStream(String fileName) 输出的目的地是一个文件路径

   • 使用步骤:

     • 创建打印流PrintStream对象,构造方法中绑定要输出的目的地
     • 使用打印流PrintStream对象中的方法write,print,println,把数据写入到目的地
     • 释放资源

   • 代码实例:

     public static void main(String[] args) throws FileNotFoundException {
             //System.out.println(97);//a
             //1.创建打印流PrintStream对象,构造方法中绑定要输出的目的地
             PrintStream ps = new PrintStream("day11\\print.txt");
             //2.使用打印流PrintStream对象中的方法write,print,println,把数据写入到目的地
             //继承自父类OutputStream的共性成员方法:打开文件查看数据的时候会查询编码表
             ps.write(97);//a
             //自己特有的成员方法:不会查询编码表,原样输出
             ps.print(97);//97
             ps.println("你好");
             ps.println(true);
             ps.println('*');
             ps.println(9.9);
             //3.释放资源
             ps.close();
         }
     

4.3 自己特有的成员方法

1. 不会查询编码表,原样输出
2. void print(任意类型的数据) :不换行
3. void println(任意类型的数据):换行