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
    }
}

有无缓冲区的不同:

File类和IO流的相关面试(二)_第1张图片

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();*/
    }
}

你可能感兴趣的:(面试,java,职场和发展)