day10【缓冲流、转换流、序列化流】

day10【缓冲流、转换流、序列化流】

主要内容

• 转换流
• 缓冲流 高效率
• 序列化流
• 打印流

教学目标

• 能够使用字节缓冲流读取数据到程序
• 能够使用字节缓冲流写出数据到文件
• 能够明确字符缓冲流的作用和基本用法
• 能够使用缓冲流的特殊功能
• 能够阐述编码表的意义
• 能够使用转换流读取指定编码的文本文件
• 能够使用转换流写入指定编码的文本文件
• 能够说出打印流的特点
• 能够使用序列化流写出对象到文件
• 能够使用反序列化流读取文件到程序中

第一章 缓冲流

昨天学习了基本的一些流，作为IO流的入门，今天我们要见识一些更强大的流。比如能够高效读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等。这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。

1.1 概述

缓冲流,也叫高效流，是对4个基本的FileXxx 流的增强，所以缓冲流也是分为4个流，按照数据类型分类：

• 字节输入缓冲流：BufferedInputStream
• 字节输出缓冲流：BufferedOutputStream
• 字符输入缓冲流：BufferedReader
• 字符输出缓冲流：BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，当需要读写数据的时候，不直接和持久设备之间交互，而改成和内存中的缓冲区中数组进行交互。

1.2 字节缓冲流

字节输出缓冲流

• public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流。
• BufferedOutputStream(OutputStream out, int size)：创建一个指定大小的缓冲输出流。

字节输出缓冲流中的方法都是从父类中继承过来的，OutputStream中的方法都可以直接使用。

代码演示

/*
    java.io.BufferedOutputStream : 继承了OutputStream
        BufferedOutputStream(OutputStream out)
            创建一个新的默认大小的缓冲输出流，通过传递的字节输出流往文件中写数据
        BufferedOutputStream(OutputStream out, int size)
            创建一个新的指定大小的缓冲输出流，通过传递的字节输出流往文件中写数据
    常用方法：
        void flush() 刷新此输出流并强制任何缓冲的输出字节被写出。
        void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。
        void write(byte[] b, int off, int len) 从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
        abstract void write(int b) 将指定的字节写入此输出流。
        void close() 关闭此输出流并释放与此流相关联的任何系统资源。
 */
public class Demo {
    public static void main(String[] args) throws IOException {
        // 创建字节输出流，用于往文件中写数据
        FileOutputStream fos = new FileOutputStream("e:\\demo\\1.txt");
        // 创建字节输出缓冲流对象，并将字节输出流传递用于往文件中写数据
        BufferedOutputStream bos = new BufferedOutputStream( fos );
        // 使用字节输出缓冲流写数据
        bos.write("往缓冲区中书写数据".getBytes());
        bos.write("然后通过字节输出流将数据写到文件中".getBytes());

        // 刷新，将缓冲区中的数据刷新到文件中
        bos.flush();
        // 关闭流对象
        bos.close();
    }
}

字节输入缓冲流

• public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。
• BufferedInputStream(InputStream in, int size)：创建一个指定大小的缓冲输入流。

字节输入缓冲流中的方法都是从父类中继承过来的，InputStream中的方法都可以直接使用。

代码演示

/*
    java.io.BufferedInputStream  : 继承了InputStream
        public BufferedInputStream(InputStream in)
            创建一个新的默认大小的缓冲输入流，通过传递的字节输入流从文件中读数据
        BufferedInputStream(InputStream in, int size)
            创建一个新的指定大小的缓冲输入流，通过传递的字节输入流从文件中读数据
    常用方法：
        abstract int read() 从输入流读取数据的下一个字节。
        int read(byte[] b) 从输入流中读取一些字节数，并将它们存储到缓冲器阵列 b 。
        int read(byte[] b, int off, int len) 从输入流读取最多 len个字节的数据到字节数组。
        void close() 关闭此输入流并释放与流相关联的任何系统资源。
 */
public class Demo {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流，用于从文件中读取数据
        FileInputStream fis = new FileInputStream("e:\\demo\\1.txt");
        // 创建字节输入缓冲流对象，并将字节输入流传递用于从文件中读取数据
        BufferedInputStream bis = new BufferedInputStream( fis );

        // 一次读取一个字节模板代码
       /*
        // 定义变量，记录读取到的字节数据
        int ch = 0;
        while( (ch = bis.read()) != -1 ) {
            System.out.println( ch );
        }*/

        // 一次读取多个字节模板代码
        // 定义数组，用来保存每次读取的数据
        byte[] buff = new byte[1024];
        // 定义变量 ，记录读取到的有效的字节数据
        int len = 0;
        while( ( len = bis.read(buff)) != -1  ){
            System.out.println(new String(buff,0,len));
        }

        // 关闭流对象
        bis.close();
    }
}

效率测试

分别使用字节流和字节流缓冲区完成文件的复制，对比效率。

字节流文件复制演示

public class Demo {
    public static void main(String[] args) throws IOException {
        // 测试时间
        long long1 = System.currentTimeMillis();
        // 创建自节输入流对象，读取需要复制的文件
        FileInputStream fis = new FileInputStream("e:\\demo\\1.avi");
        // 创建字节输出流对象，将读取到的数据写到文件中
        FileOutputStream fos = new FileOutputStream("e:\\demo\\2.avi");
//        // 一次读取一个字节复制文件
//        int ch = 0;
//        while( (ch = fis.read()) != -1 ) {
//            // 将读取到的数据写到文件中
//            fos.write(ch);
//        }
        // 一次读取多个字节复制
        byte[] buff = new byte[1024];
        int len = 0;
        while( ( len = fis.read(buff)) != -1 ) {
            // 将读取到的数据写出去
            fos.write(buff,0,len);
        }

        // 关闭流对象
        fis.close();
        fos.close();

        long long2 = System.currentTimeMillis();
        System.out.println("复制的时间为：" + (long2 - long1) );
    }
}

字节缓冲流文件复制演示

public class Demo {
    public static void main(String[] args) throws IOException {
        // 测试时间
        long long1 = System.currentTimeMillis();

        // 创建自节输入缓冲流对象，读取需要复制的文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("e:\\demo\\1.avi"));

        // 创建字节输出缓冲流对象，将读取到的数据写到文件中
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("e:\\demo\\2.avi"));
//        // 一次读取一个字节复制文件
//        int ch = 0;
//        while( (ch = bis.read()) != -1 ) {
//            // 将读取到的数据写到文件中
//            bos.write(ch);
//        }
        // 一次读取多个字节复制
        byte[] buff = new byte[1024];
        int len = 0;
        while( ( len = bis.read(buff)) != -1 ) {
            // 将读取到的数据写出去
            bos.write(buff,0,len);
        }

        // 关闭流对象
        bis.close();
        bos.close();

        long long2 = System.currentTimeMillis();
        System.out.println("复制的时间为：" + (long2 - long1) );
    }
}

1.3 字符缓冲流

字符输出流缓冲区

• public BufferedWriter(Writer out)： 创建一个新的默认大小缓冲输出流。
• BufferedWriter(Writer out, int sz)：创建一个新的指定大小缓冲输出流。

字符输出缓冲流中的方法都是从Writer父类中继承过来的，可以直接使用。

特有方法：newLine()：获取系统的换行符并换行。

代码演示

/*
    java.io.BufferedWriter 字符输出流缓冲流 继承 Writer
        BufferedWriter(Writer out)
            创建使用默认大小的输出缓冲区并使用字符输出流写出数据。
        BufferedWriter(Writer out, int sz)
            创建使用指定大小的输出缓冲区并使用字符输出流写出数据。
    abstract void close() 关闭流，先刷新。
    abstract void flush() 刷新流。
    void write(char[] cbuf) 写入一个字符数组。
    abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
    void write(int c) 写一个字符
    void write(String str) 写一个字符串
    void write(String str, int off, int len) 写一个字符串的一部分。

    特有方法：
        void newLine() 获取系统并写一行行分隔符。
 */

public class Demo {
    public static void main(String[] args) throws IOException {
        // 创建字符输出缓冲流对象，并传递字符输出流写出数据
        BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\demo\\1.txt"));
        // 往文件中写出数据
        bw.write(23456);
        // 写出换行符
        bw.newLine();
        for( int i = 0; i < 10; i++ ) {
            // 往文件中写出字符串数据
            bw.write("特有方法能够获取系统的换行符");
            // 写出换行符
            bw.newLine();
            // 将缓冲区中的数据刷新到文件中
            bw.flush();
        }

        // 关流
        bw.close();
    }
}

字符输入流缓冲区

• public BufferedReader(Reader in) ：创建一个新的默认大小的缓冲输入流。
• BufferedReader(Reader in, int sz) ：创建一个新的指定大小的缓冲输入流。

字符输入缓冲流中的方法都是从Reader父类中继承过来的，可以直接使用。

特有方法：readLine()：一次读取一行数据。一行被视为由换行符（’\ n’），回车符（’\ r’）中的任意一个，紧跟换行符的回车符或通过到达文件末尾终止。

代码演示

/*
    java.io.BufferedReader  字符输入流缓冲流 继承 Reader
        BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
        BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。

    特有方法：
        String readLine() 读一行文字。
        一行被视为由换行符（'\ n'），回车符（'\ r'）中的任意一个，紧跟换行符的回车符或通过到达文件末尾终止。
 */

public class Demo {
    public static void main(String[] args) throws IOException {
        // 创建字符输入缓冲流对象,并传递字符输入流对象，用来读取数据
        BufferedReader br = new BufferedReader(new FileReader("e:\\demo\\1.txt"));

        // 一次读取一行数据模板代码
      	// 定义字符串，保存读取到的一行数据
        String line;
        while( ( line = br.readLine() ) != null ) {
            System.out.println(line);
        }

        // 关流
        br.close();
    }
}

1.4 练习:文本排序

请将文本信息恢复顺序。

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

案例分析

1. 逐行读取文本信息。
2. 解析文本信息到集合中。
3. 遍历集合，按顺序，写出文本信息。

案例实现

/*

    1、使用字符输入缓冲流一次读取一行文本数据
    2、将读取到的文本数据进行序号和文字的切割
    3、创建Map集合，key值保存序号，value值保存文件数据
    4、将切割后的数据使用字符输出缓冲流写到文件中
 */

public class Demo {
    public static void main(String[] args) throws IOException {
        // 使用字符输入缓冲流一次读取一行文本数据
        BufferedReader br = new BufferedReader(new FileReader("e:\\demo\\a.txt"));

        // 创建Map集合，保存读取切割后的数据
        HashMap map = new HashMap<>();
        // 读取数据
        String line;
        while(( line = br.readLine()) != null  ) {
            // 对读取到的数据进行切割
            String[] split = line.split("\\.");
            // 将切割后的字符串保存到map集合中
            map.put(split[0],split[1]);
        }
        // 创建字符输出缓冲流将集合中的数据写到文件中
        BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\demo\\b.txt"));

        // 遍历Map集合，取出其中的数据
        for( String key : map.keySet() ) {
            // 获取value值
            String value = map.get(key);
            // 将key和value进行拼接
            line = key + "." + value;
            // 将拼接后的数据写到文件中
            bw.write(line);
            // 换行
            bw.newLine();
        }

        // 关流
        br.close();
        bw.close();
    }
}

第二章 转换流

2.1 字符编码和字符集

字符编码

计算机中储存的数据都是用二进制数字表示的，而如果要把生活中的数字、英文、汉字、标点符号等数据保存到计算机中，就需要先把生活中的这些数据转成二进制数据，然后才能让计算机来识别生活中的各类数据，进而对这些数据进行处理。而我们在屏幕上看到的并不是二进制数据，而是我们能够识别的数字、英文、标点符号、汉字等字符。那是将计算机中的二进制数转换之后的结果。

为了完成生活中的数据和计算机中的二进制数据之间的相互转换关系，老美在发明计算机的时候就基于：生活中的字符和计算机中二进制的数据做了一张固定的转换关系表，这个表就是ASCII编码表。

老美将生活中的所有字符、数字、符号等都编进了编码表中，并且每个字符都对应一个固定的编码值。

计算机按照编码表的规则，将计算机不能直接识别的字符转换为能够识别的二进制数据，然后存储到计算机中，这个过程我们称为：编码 。

反之，将存储在计算机中的二进制数按照编码表规则解析显示出来，变成能够让我们使用者识别的字符，这个过程我们称为：解码 。

比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本f符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

• 字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

字符集

• 字符集 Charset：是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

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

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

• 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编码。它使用一至四个字节为每个字符编码，编码规则：
    1. 128个US-ASCII字符，只需一个字节编码。
    2. 拉丁文等字符，需要二个字节编码。
    3. 大部分常用字（含中文），使用三个字节编码。
    4. 其他极少使用的Unicode辅助字符，使用四字节编码。

2.2 编码引出的问题

通过了解编码表我们知道，字符和二进制之间的转换必须使用同一张码表，如果编码和解码使用的编码表不统一，就无法正常的进行编码和解码的操作，造成乱码现象。

在IDEA中，都是默认的UTF-8编码。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

// 演示编码表造成的乱码现象
public class Demo {
    public static void main(String[] args) throws IOException {
        // 创建字符输入流，读取字符数据
        FileReader fr = new FileReader("e:\\demo\\jbk.txt");
        // 定义变量接收数据
        int ch = 0;
        while( (ch = fr.read()) != -1 ) {
            System.out.println((char)ch); // ���
        }
        // 关流
        fr.close();
    }
}

编码表的读取特点

编码表中对每个字符的编码规则：

GBK:

在GBK编码表中，它使用2个字节表示一个字符：

第一个字节：要求最高位必须是110， 1xxx xxxx      1010 0010    0101 0101

第二个字节：最高位可以是0也可以是1

当我们使用GBK编码表从底层读取字节数据时，如果读取的第一个字节数据最高位为1，这时计算机会自动的连着读取2个字节，查阅GBK编码表，找到对应的字符。

UTF-8:

一个字节表示字符的规律：0xxx xxxx

二个字节表示字符的规律：

110x xxxx

10xx xxxx

三个字节表示字符的规律：

1110 xxxx

10xx xxxx

10xx xxxx

当我们使用UTF-8编码表从底层读取字节数据时，会根据第一个字节的最高位来决定到底是几个字节一起读取查阅编码表：如下

当第一位是 0  时：  读取一个字节就查阅编码表。

当第一位是110 时：  读取两个字节就查阅编码表。

当第一位是1110时：  读取三个字节就查阅编码表。

代码演示

// 演示编码表造成的乱码现象
public class Demo {
    public static void main(String[] args) {
        //能看懂的字符数据
        String str = "联通";
        //编码成看不懂的字节数组
        byte[] bytes = str.getBytes();

        for( byte b : bytes){
            //取当前字节的二进制最后8位
            int x = b & 0b11111111;
            System.out.println(b + "..二进制：" + Integer.toBinaryString(b) + "..取后8位：" + Integer.toBinaryString(x));
        }
    }
}

2.3 InputStreamReader类

转换流java.io.InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

• InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。
• InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。
  • String charsetName：编码表不区分大小写。

构造举例，代码如下：

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

指定编码读取

public class Demo {
    /*
        java.io.InputStreamReader:是从字节流到字符流的桥梁 。继承Reader
            InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。
            InputStreamReader(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。
                String charsetName：编码表的名称不区分大小写。
     */
    public static void main(String[] args) throws IOException {
        // 创建字节转字符转换流对象
        InputStreamReader isr1 = new InputStreamReader(new FileInputStream("e:\\demo\\1.txt"));
        // 读取数据
        int ch = 0;
        while( (ch = isr1.read() ) != -1 ) {
            System.out.println((char)ch);// ���
        }
        // 关流
        isr1.close();

        // 创建字节转字符转换流对象,并指定编码表
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream("e:\\demo\\1.txt"),"GBK");
        // 读取数据
        int ch1 = 0;
        while( (ch1 = isr2.read() ) != -1 ) {
            System.out.println((char)ch1); // 你好
        }
        // 关流
        isr2.close();
    }
}

2.4 OutputStreamWriter类

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集讲字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

• OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。
• OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。
  • String charsetName：编码表的名称不区分大小写。

构造举例，代码如下：

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

指定编码写出

public class Demo {
    /*
        java.io.OutputStreamWriter：是从字符流到字节流的桥梁 继承Writer类
            OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
            OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。
                String charsetName：编码表不区分大小写
     */
    public static void main(String[] args) throws IOException {
        // 创建字符转字节转换输出流 默认编码表
        OutputStreamWriter osw1 = new OutputStreamWriter(new FileOutputStream("e:\\demo\\utf.txt"));
        // 写出数据
        osw1.write("你好"); // 6个字节
        // 刷新数据
        osw1.flush();
        // 关流
        osw1.close();

        // 创建字符转字节转换输出流 指定编码表
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("e:\\demo\\gbk.txt"),"gbk");
        // 写出数据
        osw2.write("你好"); // 4个字节
        // 刷新数据
        osw2.flush();
        // 关流
        osw2.close();
    }
}

转换流理解图解

转换流是字节与字符间的桥梁！

2.5 练习：转换文件编码

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

案例分析

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

案例实现

public class Demo {
    public static void main(String[] args) throws IOException {
        // 创建字节转字符输入转换流，读取gbk文本数据 指定为gbk格式
        InputStreamReader isr = new InputStreamReader(new FileInputStream("e:\\demo\\gbk.txt"),"gbk");
        // 创建字符转字节转换输出流
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("e:\\demo\\utf.txt"));
        // 读取数据
        int ch = 0;
        while( ( ch = isr.read()) != -1 ) {
            // 将读取到的数据写到文件中
            osw.write(ch);
            // 刷新
            osw.flush();
        }

        // 关流
        osw.close();
        isr.close();
    }
}

第三章 序列化

3.1 概述

我们在程序中创建出来的所有对象，当程序结束之后都会从内测中被清除。如果希望创建出来的对象在程序结束之后还能再次拿到并使用，就可以使用java中提供的序列化和反序列化流。

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

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

3.2 ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

• public ObjectOutputStream(OutputStream out)： 创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

1. 一个对象要想序列化，必须满足两个条件:

• 该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。

• 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

• 针对于静态的成员变量不会被序列化。

  public class Person implements java.io.Serializable{
  private String name;
  private int age;
  public Person() {
  }
  public Person(String name, int age) {

        this.name = name;
        this.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;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
  

  }

2.写出对象方法

• public final void writeObject (Object obj) : 将指定的对象写出。

  /*
  java.io.ObjectOutputStream : 序列化流，将对象写到文件中 继承OutputStream
  ObjectOutputStream(OutputStream out)
  创建一个写入指定的OutputStream的ObjectOutputStream。
  通过字节输出流将对象写到指定的文件中
  void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。
  java.io.NotSerializableException
  1、java中规定，被序列化的类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，
  不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。
  2、该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。
  3、针对于静态的成员变量不会被序列化。
  */
  public class Demo {
  public static void main(String[] args) throws IOException {
  // 创建序列化流对象
  ObjectOutputStream ois = new ObjectOutputStream(new FileOutputStream(“e:\demo\1.txt”));
  // 创建需要写出的Person对象
  Person p = new Person(“大美女”,18);
  // 使用序列化流将对象写到指定的文件中
  ois.writeObject§;

        // 关闭流对象
        ois.close();
    }
  

  }

3.3 ObjectInputStream类

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

构造方法

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

反序列化操作1

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

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

  /*
  java.io.ObjectInputStream : 反序列化流，将文件中的对象读取到程序中 继承OutputStream
  ObjectInputStream(InputStream in)
  创建从指定的InputStream读取的ObjectInputStream。
  */
  public class Demo {
  public static void main(String[] args) throws IOException, ClassNotFoundException {
  // 创建反序列化对象
  ObjectInputStream ois = new ObjectInputStream(new FileInputStream(“e:\demo\1.txt”));
  // 读取文件中的对象
  Object o = ois.readObject();
  // 打印读取到的对象
  System.out.println("o = " + o);
  }
  }

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

反序列化操作2

如果某个类实现了Serializable接口，JVM就会根据类的定义给class文件中添加一个序列号：serialVersionUID，而序列号会根据类的定义改变而改变。当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。发生这个异常的原因如下：

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

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

public class Person implements java.io.Serializable{
  	private static final long serialVersionUID = 1L; 
    private String name;
    private int age;
    public Person() {
    }
    public Person(String name, int age) {

        this.name = name;
        this.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;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.4 练习：序列化集合

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

案例分析

1. 把若干学习对象 ，保存到集合中。
2. 把集合序列化。
3. 反序列化读取时，只需要读取一次，转换为集合类型。
4. 遍历集合，可以打印所有的学生信息

案例实现

public class SerTest {
	public static void main(String[] args) throws Exception {
		// 创建 学生对象
		Student student = new Student("老王", "laow");
		Student student2 = new Student("老张", "laoz");
		Student student3 = new Student("老李", "laol");

		ArrayList arrayList = new ArrayList<>();
		arrayList.add(student);
		arrayList.add(student2);
		arrayList.add(student3);
		// 序列化操作
		// serializ(arrayList);
		
		// 反序列化  
		ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("list.txt"));
		// 读取对象,强转为ArrayList类型
		ArrayList list  = (ArrayList)ois.readObject();
		
      	for (int i = 0; i < list.size(); i++ ){
          	Student s = list.get(i);
        	System.out.println(s.getName()+"--"+ s.getPwd());
      	}
	}

	private static void serializ(ArrayList arrayList) throws Exception {
		// 创建 序列化流 
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
		// 写出对象
		oos.writeObject(arrayList);
		// 释放资源
		oos.close();
	}
}

第四章 打印流

4.1 概述

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

4.2 PrintStream类

构造方法

• public PrintStream(String fileName)： 使用指定的文件名创建一个新的打印流。

构造举例，代码如下：

PrintStream ps = new PrintStream("ps.txt")；

改变打印流向

System.out就是PrintStream类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个"小把戏"，改变它的流向。

public class PrintDemo {
    public static void main(String[] args) throws IOException {
		// 调用系统的打印流,控制台直接输出97
        System.out.println(97);
      
		// 创建打印流,指定文件的名称
        PrintStream ps = new PrintStream("ps.txt");
      	
      	// 设置系统的打印流流向,输出到ps.txt
        System.setOut(ps);
      	// 调用系统的打印流,ps.txt中输出97
        System.out.println(97);
    }
}