File类和IO流的相关面试（二）

一.IO流

1.什么是IO?

I：Input，数据的读取，数据的输入

        数据的输入，可以是从键盘输入，从文件读取，从网络接收...

O：Output，写数据，数据的输出

        数据的输出，可以是输出到控制台，写到文件，发生到网络中...

2.在java中要进行IO操作需要使用IO流类来完成

现在说的是传统的IO，阻塞式IO。

后面还会有NIO（非阻塞式IO）和AIO（异步IO）

基础阶段的IO流类：

（1）按照方向分

输入流类：

        InputStream，Reader系列

输出流类：

        OutputStream，Writer系列

（2）按照操作数据的方式，单位分：

字节流：

        InputStream，OutputStream系列

字符流：

        Reader，Writer

（3）按照角色不同

节点流：

        和数据的源头/目的地连接的IO流：

                FileInputStream，FileOutputStream，FileReader，FileWriter：读写文件

                ByteArrayInputStream，ByteArrayOutputStream，CharArrayReader，CharArrayWriter：读写数组

                ....

处理流/包装流/装饰流：

        它是在其他IO流基础上，增加功能用的

                BufferedInputStream，BufferedOutputStream，BufferedReader，BufferedWriter，给其他IO流增加缓冲功能。

                InputStreamReader，OutputStreamReader，给其他IO流转换类型用的，或者给其他IO编码，解码用的

                ...

区分它们的依据是创建它们的对象的方式，如果是处理流，创建调用它们的构造器创建对象时，必须传入另一个IO流对象。

        FileInputStream(String name)：节点流，参数不是IO流类型

        BufferedInputStream(InputStream in)：处理流，参数是IO流类型

3.IO流类的四个基类，四个超类，四个父类，其他的IO流都是从它们演变过来，是它们的子类。

        字节输入流：InputStream

        字节输出流：OutputStream

        字符输入流：Reader

        字符输出流：Writer

代码如下：

public class TestIO {
    @Test
    public void test02(){
        Scanner input = new Scanner(System.in);//从键盘输入
        System.out.print("输入一个姓名:");
        String name = input.next();
        System.out.println("name = " + name);
        input.close();
    }
     
    @Test
    public void test01(){
        System.out.println("hello");//这个也是IO操作，把数据输出到控制台
    }
}

4.文件IO流（输入流）

（1）FileInputStream类

        如果文件不存在，会报错java.io.FileNotFoundException：xxx（系统找不到指定的文件）

父类：InputStream类（字节输入流）

public int read()：从输入流读取一个字节。返回读取的字节值。虽然读取了一个字节，但是会自动提升为int类型。如果已经到达流末尾，没有数据可读，则返回-1

public int read(byte[] b)：从输入流中读取一些字节数，并将它们存储到字节数组 b 中。每次最多读取b.length个字节。返回实际读取的字节个数。如果已经到达流末尾，没有数据可读，则返回-1.

public int read(byte[] b,int off,int len)：从输入流中读取一些字节数，并将它们存储到字节数组 b 中，从b[off]开始存储，返回实际读取的字节个数。如果已经到达流末尾，没有数据可读，则返回-1

public void close()：关闭此输入流并释放与此流相关联的任何系统资源。

（2）FileOutputStream类

        如果文件不存在，会自动创建

        如果文件已存在，会覆盖原来的内容

        如果要追加，在创建FileOutputStream类对象时，加一个参数true

它的父类是OutputStream类，字节输出流

public void write(int b)：将指定的字节输出。虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。

public void write(byte[] b)：将b.length字节从指定的字节数组写入此输出流。

public void write(byte[] b,int off,int len)：从指定的字节数组写入 len 字节，从偏移量 off 开始输出到此输出流。

public void close()：关闭此输入流并释放与此流相关联的任何系统资源。

（3）FileReader类

父类 Reader类：

public int read()： 从输入流读取一个字符。 虽然读取了一个字符，但是会自动提升为int类型。返回该字符的Unicode编码值。如果已经到达流末尾了，则返回-1。

public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。每次最多读取cbuf.length个字符。返回实际读取的字符个数。如果已经到达流末尾，没有数据可读，则返回-1。

public int read(char[] cbuf,int off,int len)：从输入流中读取一些字符，并将它们存储到字符数组 cbuf中，从cbuf[off]开始的位置存储。每次最多读取len个字符。返回实际读取的字符个数。如果已经到达流末尾，没有数据可读，则返回-1。

public void close()：关闭此流并释放与此流相关联的任何系统资源。

（4）FileWriter类

父类Writer类

public void write(int c)：写入单个字符。

public void write(char[] cbuf)：写入字符数组。

public void write(char[] cbuf, int off, int len)：写入字符数组的某一部分,off数组的开始索引,len写的字符个数。

public void write(String str)：写入字符串。

public void write(String str, int off, int len)：写入字符串的某一部分,off字符串的开始索引,len写的字符个数。

public void flush()：刷新该流的缓冲。

public void close()：关闭此流，但要先刷新它。

5.IO流操作的步骤：

① 先选择合适的IO流类，创建它的对象

② 读或写操作

③ 关闭IO流

        因为IO流类的对象会在JVM内存中开辟空间。这个部分的内存，可以有JVM的GC自动回收

        但是IO流的操作还会在JVM内存的外部开辟空间，因为IO操作需要用到操作系统的一些函数，这些内存GC是无法回收的。

        那么要通过调用close方法，通知操作系统释放对应的内存。

代码如下：

FileInputStream类

public class TestFileInputStream {
    @Test
    public void test04() throws IOException {
        /*
        要以字节的方式读取一个文件：当前模块下的文件1.txt
         */
        FileInputStream fis = new FileInputStream("1.txt");//相对路径
 
        byte[] data = new byte[2];
        while(true) {
            int len = fis.read(data);//数据读取到data字节数组中
            if(len == -1){
                break;
            }
            System.out.println("len = " + len);
//            System.out.println(Arrays.toString(data));//[97,98]
            System.out.println(new String(data,0,len));//本次读取了几个字节，就用几个字节构造字符串
        }
 
        fis.close();
    }
 
 
    @Test
    public void test03() throws IOException {
        /*
        要以字节的方式读取一个文件：当前模块下的文件1.txt
         */
        FileInputStream fis = new FileInputStream("1.txt");//相对路径
 
        while(true){
            int read = fis.read();
            if(read == -1){
                break;
            }
            System.out.println(read);
        }
 
        fis.close();
    }
 
 
    @Test
    public void test02() throws IOException {
        /*
        要以字节的方式读取一个文件：当前模块下的文件1.txt
         */
        FileInputStream fis = new FileInputStream("1.txt");//相对路径
 
        byte[] data = new byte[2];
        int len = fis.read(data);//数据读取到data字节数组中
        System.out.println("len = " + len);//2
        System.out.println(Arrays.toString(data));//[97,98]
 
        len = fis.read(data);
        System.out.println("len = " + len);//1
        System.out.println(Arrays.toString(data));//[99, 98]   这个98是上次读取的，本次只读取了一个字节
 
        len = fis.read(data);
        System.out.println("len = " + len);//-1
        System.out.println(Arrays.toString(data));//[99, 98]   这个99,98是上次读取的，本次只读取了一个字节
 
        fis.close();
    }
 
    @Test
    public void test01() throws IOException {
        /*
        要以字节的方式读取一个文件：当前模块下的文件1.txt
         */
        FileInputStream fis = new FileInputStream("1.txt");//相对路径
 
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
 
        fis.close();
    }
}

FileOutputStream类（代码演示）

public class TestFileOutputStream {
    @Test
    public void test03() throws IOException {
        //输出hello到1.txt，接着原来内容写
        FileOutputStream fos = new FileOutputStream("1.txt",true);//已存在  true表示追加
 
        //把字符串转为字节数组
        fos.write("hello".getBytes());
 
        fos.close();
    }
 
 
    @Test
    public void test02() throws IOException {
        //输出houxiaosun到1.txt
        FileOutputStream fos = new FileOutputStream("1.txt");//已存在
 
        //把字符串转为字节数组
        fos.write("houxiaosun".getBytes());
 
        fos.close();
    }
 
    @Test
    public void test01() throws IOException {
        //输出chai到1.txt
        FileOutputStream fos = new FileOutputStream("1.txt");
 
        //把字符串转为字节数组
        fos.write("chai".getBytes());
 
        fos.close();
    }
}

FileReader类

public class TestFileReader {
 
    @Test
    public void test02()throws IOException{
         /*
        要以字符的方式读取一个文件：当前模块下的文件1.txt
         */
        FileReader fr = new FileReader("1.txt");
 
        char[] data = new char[2];
        int len;
        while((len = fr.read(data)) != -1){
            System.out.println(new String(data,0,len));
        }
 
        fr.close();
    }
 
    @Test
    public void test01()throws IOException {
         /*
        要以字节的方式读取一个文件：当前模块下的文件1.txt
         */
        FileInputStream fis = new FileInputStream("1.txt");//相对路径
 
        byte[] data = new byte[3];
        while(true) {
            int len = fis.read(data);//数据读取到data字节数组中
            if(len == -1){
                break;
            }
            System.out.println(new String(data,0,len));//本次读取了几个字节，就用几个字节构造字符串
            //new String就是解码操作，但是发现乱码了
        }
 
        fis.close();
    }
}

FileWriter类

public class TestFileWriter {
    @Test
    public void test()throws IOException {
        //输出一句话到1.txt
        FileWriter fw = new FileWriter("1.txt",true);//true表示追加
        fw.write("我爱你");
        fw.close();
    }
}

练习题：使用文件字节流复制一个视频文件

例如：D:\atguigu\javaee\JavaSE20220106\video\day0107_01video\day0107_01JavaSE阶段学什么.avi

复制到当前工程的根目录

复制文件：其实就是读一个文件，然后把读取的数据写到另一个文件

public class Exercise3 {
    @Test
    public void test()throws IOException{
        FileInputStream fis = new FileInputStream("D:\\atguigu\\javaee\\JavaSE20220106\\video\\day0107_01video\\day0107_01JavaSE阶段学什么.avi");
        //要求上面这个文件必须存在，否则会报错
 
        FileOutputStream fos = new FileOutputStream("day0107_01JavaSE阶段学什么1.avi");
        //下面这个文件可以不存在
 
        byte[] data = new byte[1024];//一次读取1KB
    /*    while(fis.read(data) != -1){//错误，因为这个循环会导致每次循环读了两次，一次用于判断，一次用于输出
            fos.write(fis.read(data));
        }*/
        int len;
        while((len= fis.read(data)) !=-1){
            fos.write(data,0,len);
        }
 
        fis.close();
        fos.close();
    }
 
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\\atguigu\\javaee\\JavaSE20220106\\video\\day0107_01video\\day0107_01JavaSE阶段学什么.avi");
        //要求上面这个文件必须存在，否则会报错
 
        FileOutputStream fos = new FileOutputStream("day0107_01JavaSE阶段学什么.avi");
        //下面这个文件可以不存在
 
        byte[] data = new byte[1024];//一次读取1KB
        while(true){
            int len = fis.read(data);//从源文件读取len个字节
            if(len == -1){
                break;
            }
            fos.write(data,0,len);//把本次读取的len个字节写到目标文件中
        }
 
        fis.close();
        fos.close();
    }
}

6.IO流的问题

（1）关于直接基于"文件夹/目录"创建IO流对象是错误的

会报java.io.FileNotFoundException：d:\download（拒绝访问）

（2）输出流如果不能及时关闭（因为可能后面还要用），但是又想要数据及时输出，可以调用flush方法，但是如果后面不用啦，一定要close。因为close不仅仅是刷数据的问题，还涉及到内存回收问题。

public class TestProblem {
    @Test
    public void test02()throws IOException{
        FileWriter fw = new FileWriter("1.txt");
        fw.write("柴林燕");
        /*
        像FileWriter等很多的输出流的内部有自己的一个小小缓冲区，
        它在调用write方法时，会先将数据写到缓冲区。
        当缓冲区满的时候，会自动“溢出”到文件。
        当缓冲区没满的时候，会close方法执行时，把缓冲区的数据“清空”输出。
         */
        //如果希望数据及时写出，但是暂时还不close
        fw.flush();//刷新
 
        fw.write("是Java讲师");
        fw.flush();
 
        fw.close();
        fw.write("很棒");//java.io.IOException: Stream closed
        fw.close();//这个就是错误的，因为已经close过了
    }
 
    @Test
    public void test01()throws IOException {
//        FileInputStream fis = new FileInputStream("d:\\download");
        //java.io.FileNotFoundException: d:\download (拒绝访问。)
//        文件IO必须基于文件路径创建对象
        //"d:\\download"这个是一个文件夹的路径，不是一个文件的路径
 
//        FileOutputStream fos = new FileOutputStream("d:\\download");
        //java.io.FileNotFoundException: d:\download (拒绝访问。)
 
        //就算是让 FileOutputStream帮你自动创建文件，也必须在IO流的构造器中，指明文件的名称。
    }
}

7.缓冲流：

        作用是给其他IO流增加缓冲区，提高效率

缓冲流的使用必须基于其他的IO流，也就是说，缓冲流它只能是装修（包装）别的流。

BufferedInputStream：只能包装InputStream系列的IO流

BufferedOutputStream：只能包装OutputStream系列的IO流

BufferedReader：只能包装Reader系列的IO流

BufferedWriter：只能包装Writer系列的IO流

原理：所有的缓存流在内部会开辟一块更大的缓存区，默认大小是8192字节/字符（本质就是一个8192长度的byte/char数组）

        另外，对于BufferedReader和BufferedWriter来说，它除了提高效率之外，

还可以使用下面两个方法，使得读写更方便：

BufferedReader类的  String readLine() 读取一整行

BufferedWriter类的void newLine()  写入一整行

代码演示：

public class TestBuffered {
    @Test
    public void test05()throws IOException{
        //一行一行的写数据
        FileWriter fw = new FileWriter("1.txt");
        BufferedWriter bw = new BufferedWriter(fw);
 
        bw.write("hello");
        bw.newLine();//一行一行的写数据
        bw.write("java");
        bw.newLine();
        bw.write("world");
        bw.newLine();
        bw.write("aa");
 
        bw.close();
        fw.close();
    }
 
    @Test
    public void test04()throws IOException{
        //一行一行的写数据
        FileWriter fw = new FileWriter("1.txt");
        fw.write("hello");
        fw.write("\r\n");
        fw.write("java");
        fw.write("\r\n");
        fw.write("world");
        fw.write("\r\n");
        fw.write("aa");
        fw.close();
    }
 
    @Test
    public void test03()throws IOException {
        FileReader fr = new FileReader("1.txt");
        BufferedReader br = new BufferedReader(fr);//包装fr
        String str;
        while((str=br.readLine())!=null){//一行一行的读数据
            System.out.println(str);
        }
        br.close();
        fr.close();
    }
 
    @Test
    public void test02()throws IOException {
        long start = System.currentTimeMillis();
        /*
        演示 BufferedInputStream包装FileInputStream
             BufferedOutputStream包装FileOutputStream
         来完成复制文件。
         D:\software\IntelliJ IDEA\ideaIU-2020.3.1.win.zip
         */
        FileInputStream fis = new FileInputStream("D:\\software\\IntelliJ IDEA\\ideaIU-2020.3.1.win.zip");
        BufferedInputStream bis = new BufferedInputStream(fis);//BufferedInputStream包装FileInputStream的对象
 
        FileOutputStream fos = new FileOutputStream("D:\\idea2.zip");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
 
        byte[] data = new byte[1024];
        int len;
        while((len = bis.read(data)) != -1){
            bos.write(data,0,len);
        }
 
        bis.close();
        fis.close();
        bos.close();
        fos.close();
 
 
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end-start));//耗时：6164
    }
    @Test
    public void test01()throws IOException {
        long start = System.currentTimeMillis();
        /*
        演示 BufferedInputStream包装FileInputStream
             BufferedOutputStream包装FileOutputStream
         来完成复制文件。
         D:\software\IntelliJ IDEA\ideaIU-2020.3.1.win.zip
         */
        FileInputStream fis = new FileInputStream("D:\\software\\IntelliJ IDEA\\ideaIU-2020.3.1.win.zip");
        FileOutputStream fos = new FileOutputStream("D:\\idea3.zip");
 
        byte[] data = new byte[1024];
        int len;
        while((len = fis.read(data)) != -1){
            fos.write(data,0,len);
        }
 
        fis.close();
        fos.close();
 
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end-start));//42063
    }
}

有无缓冲区的不同：

8.IO流的关闭顺序：

IO流有依赖关系。外层的包装流依赖于内存的被包装流。
        比如：BufferedInputStream 依赖于 FileInputStream
                   BufferedOutputStream 依赖于 FileOutputStream
 
             如果把内层的IO先关闭了，外层IO流就失去了依赖，就会报错。
         比喻：我坐在凳子上，我依赖于凳子，如果把凳子先撤了，我就会摔倒。
         先让我站起来，然后撤凳子。
 
         关闭的顺序是：先关闭外层的包装流，再关闭内层的被包装流。
 
         本质：
            这段代码数据的流向： 源文件 -> fis -> bis -> data数组  -> bos -> fos ->目标文件.
            BufferedOutputStream和FileOutputStream，如果把fos先关了，
            bos中的缓冲的数据没有办法完全写出。因为close时，会清空缓冲区。
 
        好记：
            fis被包装在里面的，比喻成内衣，先穿内衣，再穿外衣。
            bis相当于外套。
 
            fos是内衣，bos是外套。
 
            关闭好比是脱衣服。
            先脱外套，再脱内衣。
 
           或者，先new的后关。
 
           fis和bis有顺序关系
           fos和bos有顺序关系
 
            fis和bis 、 fos和bos是没有顺序关系。

演示代码：

public class TestClose {
    @Test
    public void test02()throws IOException {
        FileInputStream fis = new FileInputStream("D:\\atguigu\\javaee\\JavaSE20220106\\video\\day0107_01video\\day0107_01JavaSE阶段学什么.avi");
        BufferedInputStream bis = new BufferedInputStream(fis);//BufferedInputStream包装FileInputStream的对象
 
        FileOutputStream fos = new FileOutputStream("JavaSE.avi");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
 
        /*
        这段代码数据的流向： 源文件 -> fis -> bis -> data数组  -> bos -> fos ->目标文件
         */
        byte[] data = new byte[1024];
        int len;
        while((len = bis.read(data)) != -1){
            bos.write(data,0,len);
        }
 
        fis.close();
        fos.close();
        bis.close();
        bos.close();//java.io.IOException: Stream Closed
        //应该先关闭外层，再关闭内层
    }
}

 9.编码与解码问题

使用FileReader和FileWriter去操作和当前程序编码不一致的文件时，就会出现乱码的问题，怎么解决？

使用InputStreamReader：输入流

        OutputStreamReader：输出流

构造方法摘要：

InputStreamReader(InputStream in)：创建一个使用默认字符集的 InputStreamReader。

InputStreamReader(InputStream in,Charset cs)：创建使用给定字符集的 InputStreamReader。

InputStreamReader(InputStream in,CharsetDecoder dec)：创建使用给定字符集解码器的 InputStreamReader。

InputStreamReader(InputStream in,String charsetName)：创建使用指定字符集的 InputStreamReader。

代码演示：

public class TestInputStreamReader {
 
    @Test
    public void test04()throws IOException{
        //输出尚硅谷太棒了到GBK编码的1.txt文件中
        //加入缓冲流提高效率
        FileOutputStream fos = new FileOutputStream("1.txt");
        //(1)可以加入这个位置
        BufferedOutputStream bos = new BufferedOutputStream(fos);//因为被包装的fos是字节流
        OutputStreamWriter osw = new OutputStreamWriter(bos,"GBK");//把字符数据用GBK编码转为字节数据输出
        //(2)也可以加入这儿
        BufferedWriter bw = new BufferedWriter(osw);//因为osw是字符流
 
        bw.write("尚硅谷太棒了");
 
        bw.close();
        osw.close();
        bos.close();
        fos.close();
    }
 
    @Test
    public void test03()throws IOException{
        //输出尚硅谷太棒了到GBK编码的1.txt文件中
        FileOutputStream fos = new FileOutputStream("1.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");//把字符数据用GBK编码转为字节数据输出
 
        osw.write("尚硅谷太棒了");
 
        osw.close();
        fos.close();
    }
 
    @Test
    public void test02()throws IOException {
        FileInputStream fis = new FileInputStream("1.txt");
        InputStreamReader isr = new InputStreamReader(fis,"GBK");//文件的编码是GBK，用GBK解从文件读取的数据
 
        char[] data = new char[10];
        int len;
        while((len = isr.read(data)) != -1){
            System.out.println(new String(data,0,len));
        }
 
        isr.close();
        fis.close();
    }
 
    @Test
    public void test01()throws IOException {
        FileReader fr = new FileReader("1.txt");//1.txt的编码是GBK
        char[] data = new char[10];
        int len;
        while((len = fr.read(data)) != -1){
            System.out.println(new String(data,0,len));
        }
        fr.close();
    }
}

10.对象序列化和反序列化

IO流：

        字节流，可以读/写  图片，视频，文本等。

        字符流，只能读/写  文本（字符串，char）

如果要处理Java程序中的各种数据类型的数据，就需要用

DataInputStream：读Java各种基本数据类型的数据+String。

DataOutputStream：写Java各种基本数据类型的数据+String。

ObjectInputStream：读Java任意类型，包括对象。

ObjectOutputStream：写Java任意类型，包括对象。

序列化：把Java对象直接转化为字节序列过程，这个过程称为序列化，要求这个对象的类型必须实现java.io.Serializable接口，否则无法支持序列化。

反序列化：把字节序列转为Java对象的过程。

反序列化失败问题：

        当数据已经序列化好之后，对Student类做了修改，导致反序列化的代码运行失败；报错：        java.io.InvalidClassException（无效的类异常）: com.atguigu.object.Student;

local（本地） class incompatible（不相容的；矛盾的；）:stream（流） classdesc（类描述） serialVersionUID（序列化版本ID） = -3979294235569238736,local（本地） class serialVersionUID（序列化版本ID） = 5212389082514962991

        如果在类声明并实现java.io.Serializable接口时，如果没有固定serialVersionUID(序列化版本ID)值，那么会在每一次编译类的时候，会产生一个新的serialVersionUID(序列化版本ID)值。

        修改Student类，就会导致类重新编译。

如何解决这个问题？

        在类声明并实现java.io.Serializable接口时，固定 serialVersionUID(序列化版本ID)值。

不参与序列化的字段：

① transient修饰的属性字段

② static修饰的属性字段

Student类代码：

public class Student implements Serializable {
    private static final long serialVersionUID = -3979294235569238736L;
    private static int total = 1;
    private int id;
    private String name;
    private int age;
    private transient int score;//transient瞬时的，临时，序列化时遇到transient标记的字段，会忽略它
    private String tel;
 
    public Student(String name, int age, int score) {
        id=total++;
        this.name = name;
        this.age = age;
        this.score = score;
    }
 
    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;
    }
 
    public int getScore() {
        return score;
    }
 
    public void setScore(int score) {
        this.score = score;
    }
 
    public static int getTotal() {
        return total;
    }
 
    public static void setTotal(int total) {
        Student.total = total;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                ", tel='" + tel + '\'' +
                '}';
    }
}

测试代码：TestObjectIO类：

public class TestObjectIO {
 
    @Test
    public void test04()throws Exception{
        //在stu.dat文件中增加一个对象
        FileInputStream fis = new FileInputStream("stu.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);
        ArrayList list = (ArrayList) ois.readObject();
        list.add(new Student("沈彦",22,100));
        System.out.println(list);
        ois.close();
        fis.close();
 
        FileOutputStream fos = new FileOutputStream("stu.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(list);
        oos.close();
        fos.close();
    }
 
    @Test
    public void test03()throws Exception{
        Student s1 = new Student("李四",24,88);
        Student s2= new Student("王五",24,90);
        Student s3 = new Student("赵六",24,100);
        ArrayList list = new ArrayList<>();
        list.add(s1);
        list.add(s2);
        list.add(s3);
 
        //同时序列化多个对象时，怎么办？
        //放到集合里面。
        FileOutputStream fos = new FileOutputStream("stu.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(list);
        oos.close();
        fos.close();
    }
 
    @Test
    public void test02() throws IOException, ClassNotFoundException {
        Student s1 = new Student("李四",24,0);
        Student s2= new Student("王五",24,0);
        Student s3 = new Student("赵六",24,0);
        System.out.println(Student.getTotal());
 
 
        FileInputStream fis = new FileInputStream("game.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);
 
        //读的顺序要与写的顺序一致
        String name = ois.readUTF();
        int age = ois.readInt();
        char gender = ois.readChar();
        int energy = ois.readInt();
        double price = ois.readDouble();
        boolean relive = ois.readBoolean();
        Object object = ois.readObject();
 
        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("gender = " + gender);
        System.out.println("energy = " + energy);
        System.out.println("price = " + price);
        System.out.println("relive = " + relive);
        System.out.println("object = " + object);
 
        System.out.println(Student.getTotal());
 
        ois.close();
        fis.close();
 
    }
 
    @Test
    public void test01()throws IOException {
        String name ="巫师";
        int age = 300;
        char gender ='男';
        int energy = 5000;
        double price = 75.5;
        boolean relive = true;
 
        Student stu = new Student("张三",23,89);
 
        //输出到文件
        FileOutputStream fos = new FileOutputStream("game.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeUTF(name);
        oos.writeInt(age);
        oos.writeChar(gender);
        oos.writeInt(energy);
        oos.writeDouble(price);
        oos.writeBoolean(relive);
        oos.writeObject(stu);
        //java.io.NotSerializableException: com.atguigu.object.Student
 
        System.out.println(Student.getTotal());
 
        oos.close();
        fos.close();
    }
}

11.Scanner类与IO流

java.util.Scanner类，不是只能用来从键盘输入数据，它可以从任意流中扫描数据。

如果没有修改过System.in，那么Scanner  input = new Scanner(System.in)；默认是从键盘输入

在创建Scanner对象时，指定了其他的IO流，会从其他IO流中读取文本数据。

示例代码：

public class TestScanner {
    @Test
    public void test01()throws Exception{
        //从2.txt文件中获取数据
        Scanner input = new Scanner(new FileInputStream("2.txt"));
        while(input.hasNextLine()){
            String line = input.nextLine();
            System.out.println(line);
        }
        input.close();
    }

12.System类与IO流

System类中有三个常量对象：

① public final static InputStream in = null;

② public final static PrintStream out = null;

③ public final static PrintStream err = null;

常量对象正常是以大写字母开头，但System的三个常量对象是以小写字母开头，而且用 final 修饰的变量是不可变的，但是System类的底层有set方法，可以设置in，out，err的值，即下面方法：

① public static void setIn(InputStream in)

② public static void setOut(PrintStream out)

③ public static void setErr(PrintStream err)

底层是用native修饰的，来更改in，out，err的值。

private static native void setIn0(InputStream in);

private static native void setOut0(PrintStream out);

private static native void setErr0(PrintStream err);

示例代码如下：

public class TestSystem {
    @Test
    public void test02()throws IOException {
       System.setIn(new FileInputStream("2.txt"));
        //此时默认是从 2.txt 文件中获取数据
        Scanner input = new Scanner(System.in);
        while(input.hasNextLine()){
            String line = input.nextLine();
            System.out.println(line);
        }
        input.close();
    }
    @Test
    public void test01(){
        InputStream in = System.in;
        PrintStream out = System.out;
        PrintStream err = System.err;
 
 
        out.println("hello");
        err.println("world");
    }
}

13.PrintStream类

PrintStream打印流：

        ① 可以支持各种数据类型的打印

        ② 可以支持输出换行，输出不换行，还支持格式化输出

print(xxx);输出不换行

println(xxx);输出换行

printf(xx);格式化输出

        ③ 输出可以输出到各种其他IO流中，也可以直接输出到文件，也可以输出到控制台。

public class TestPrintStream {
    @Test
    public void test01()throws IOException {
        //以 UTF-8 的编码形式，输入到 3.txt 文件中
        PrintStream ps = new PrintStream("3.txt","UTF-8");
        ps.println("hello");
        ps.println("world");
        ps.close();
    }
}

14.try...catch新语法自动关闭IO流

JDK1.7版本之前：

代码如下：

public class TestTryCatch {
    @Test
    public void test01(){
        FileInputStream fis = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
        FileOutputStream fos = null;
        OutputStreamWriter osw = null;
        BufferedWriter bw = null;
        try {
            //GBK编码的1.txt，复制UTF-8的2.txt文件
            fis = new FileInputStream("1.txt");
            isr = new InputStreamReader(fis,"GBK");
            br = new BufferedReader(isr);
 
            fos = new FileOutputStream("2.txt");
            osw = new OutputStreamWriter(fos, "UTF-8");
            bw = new BufferedWriter(osw);
 
            String line;
            while((line = br.readLine()) != null){
                bw.write(line);
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
 /*           try {
                bw.close();
                osw.close();
                fos.close();
                br.close();
                isr.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }*/
            try {
                if(bw!=null) {
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(osw != null) {
                    osw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fos != null){
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
 
            try {
                if(br != null){
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
 
            try {
                if(isr != null) {
                    isr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
 
 
    }
}

这种try...catch非常麻烦，finally里面如果有异常的话，需要一个一个来try...catch很麻烦，所以JDK1.7之后，就有了新的方法

try（需要自动关闭的资源的对象的声明和创建）{

        需要异常检查的业务逻辑代码

}catch（异常类型 e）{

        异常处理代码

}finally{

        这里写的是其他的必须执行的代码，但是不是资源关闭的代码。

}

try()中不是所有类型的对象的声明和创建都可以放进去的，只能放实现了 AutoClose 接口的类型

只有在try()中声明的才会自动关闭。不在这里声明的不会自动关闭。

在try()中声明的变量，会自动加 final

public class TestTryCatch {
 
    @Test
    public void test02(){
        //GBK编码的1.txt，复制UTF-8的2.txt文件
        try(
            FileInputStream fis = new FileInputStream("1.txt");
            InputStreamReader isr = new InputStreamReader(fis,"GBK");
            BufferedReader br = new BufferedReader(isr);
 
            FileOutputStream fos = new FileOutputStream("2.txt");
            OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
            BufferedWriter bw = new BufferedWriter(osw);
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
        }catch(IOException e){
            e.printStackTrace();
        }
 
        //自动关闭，不需要写了
       /* bw.close();
        osw.close();
        fos.close();
        br.close();
        isr.close();
        fis.close();*/
    }
}