IO流：字节流、字符流、缓冲流、转换流、数据流、序列化流 --Java学习笔记

A泽予

于 2024-04-04 12:00:00 发布

阅读量745

点赞数 29

分类专栏： Java学习笔记文章标签：学习笔记 IO流字节流字符流缓冲流转换流

本文链接：https://blog.csdn.net/m0_71386740/article/details/136986928

版权

Java学习笔记专栏收录该内容

81 篇文章 2 订阅

订阅专栏

1、Filelnputstream(文件字节输入流)

2、FileOutputStream(文件字节输出流)

字节流非常适合做一切文件的复制操作

复制案例：

try-catch-finally 和 try-with-resource

字符流

1、FileReader(文件字符输入流)

2、FileWriter(文件字符输出流)

字节流、字符流的使用场景小结:

缓冲流

BufferedReader(字符缓冲输入流)

BufferedWriter(字符缓冲输出流)

不同编码读取出现乱码的问题

转换流

InputStreamReader(字符输入转换流)

OutputStreamWriter字符输出转换流

打印流

PrintStream/PrintWriter(打印流)

Printstream提供的打印数据的方案

PrintWriter提供的打印数据的方案

PrintStream和PrintWriter的区别

打印流的一种应用:输出语句的重定向

数据流

DataOutputstream(数据输出流)

Datalnputstream(数据输入流)

序列化流

Objectoutputstream(对象字节输出流)

Objectlnputstream(对象字节输入流)

IO流

读写数据的输入输出流
I指Input，称为输入流：负责把数据读到内存中去
O指Output，称为输出流：负责写数据出去

IO流的分类

IO流总体看来分为四大流

字节输入流:以内存为基准，来自磁盘文件/网络中的数据以字节的形式读入到内存中去的流
字节输出流:以内存为基准，把内存中的数据以字节写出到磁盘文件或者网络中去的流
字符输入流:以内存为基准，来自磁盘文件/网络中的数据以字符的形式读入到内存中去的流
字符输出流:以内存为基准，把内存中的数据以字符写出到磁盘文件或者网络介质中去的流

IO流的体系

字节流：

1、Filelnputstream(文件字节输入流)

作用:以内存为基准，可以把磁盘文件中的数据以字节的形式读入到内存中去

代码演示：

abc.txt内容

一个一个字节读和使用循环一个一个字节读：

import java.io.*;

public class IoTest1 {
    public static void main(String[] args) throws IOException {
        //1、创建文件字节输入流管道，与源文件接通
        //InputStream fileInputStream = new FileInputStream(new File("file_io\\src\\com\\zeyu\\abc.txt"));  new File可省略
        InputStream fileInputStream = new FileInputStream("file_io\\src\\com\\zeyu\\abc.txt");

        //2、读取文件字节数据
        //public int read() 每次读取一个字节返回,如果没有数据了，返回-1
//        int b1 = fileInputStream.read();
//        System.out.println((char)b1);
//
//        int b2 = fileInputStream.read();
//        System.out.println((char)b2);

        //使用循环读
        int b;
        while((b = fileInputStream.read()) != -1){
            System.out.print((char)b);
        }
        //读取数据的性能很差!
        //读取汉字输出会乱码!!无法避免的!!
        //流使用完毕之后，必须关闭!释放系统资源!
        fileInputStream.close();
    }
}

运行结果：

为什么会乱码？

因为中文字符在utf-8里面占三个字节，而每次读取一个字节输出显然是解码不出中文的，只会读取中文字符三个字节中的一个字节

用字节数组读和结合循环用字节数组读：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class IoTest2 {
    public static void main(String[] args) throws IOException {
        InputStream fileInputStream = new FileInputStream("file_io\\src\\com\\zeyu\\abc.txt");
        //读取文件中的字节数据，每次读取多个字节
        // public int read(byte b[])throws IOException
        //每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1
//        byte[] buffer = new byte[3];
//        int len = fileInputStream.read(buffer); //返回读取了多少个字节
//        System.out.println(new String(buffer));
//        System.out.println(len);
//
//        int len2 = fileInputStream.read(buffer);
//        //注意:读取多少，倒出多少
//        System.out.println(new String(buffer,0,len2));  //倒出0到len2的字节
//        System.out.println(len2);
//
//        int len3 = fileInputStream.read(buffer);
//        System.out.println(len3);   //-1

        //使用循环改造
        int len;
        byte[] buffer = new byte[3];
        while((len = fileInputStream.read(buffer)) != -1){
            System.out.print(new String(buffer, 0, len));
        }   //性能得到了明显的提升
            //这种方案也不能避免中文乱码问题
        fileInputStream.close();
    }
}

运行结果：

即使每次读取三个字节，依旧无法避免乱码的可能，因为若读取的字符串排列为前面俩个英文接一个中文，就会读取到前面俩个英文的（英文数字在utf-8中占一个字节）字节和中文的其中一个字节

一次性读取全部字节：

package com.zeyu.Io;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class IoTest3 {
    public static void main(String[] args) throws IOException {
        //一次性读取完文件的全部字节
        InputStream is = new FileInputStream("file_io\\src\\com\\zeyu\\abc2.txt");

        //准备一个字节数组，大小与文件的大小一样大
//        File f = new File("file_io\\src\\com\\zeyu\\abc2.txt");
//        long size = f.length();
//        byte[] buffer = new byte[(int)size];
//
//        int len = is.read(buffer);
//
//        System.out.println(new String(buffer));
//        System.out.println(len);
//        System.out.println(size);

        byte[] buffer = is.readAllBytes(); //readAllBytes() 直接把文件的全部字节读取到一个字节数组中返回
        System.out.println(new String(buffer));
    }
}

运行结果：

一次读取完文件的所有字节，当然就不会出现乱码问题了，但是文件过大依旧可能出现内存溢出问题

2、FileOutputStream(文件字节输出流)

作用:以内存为基准，把内存中的数据以字节的形式写出到文件中去

代码演示：

import java.io.FileOutputStream;
import java.io.IOException;

public class IoTest4 {
    public static void main(String[] args) throws IOException {
        //创建一个字节输出流管道与目标文件接通
        FileOutputStream os = new FileOutputStream("file_io\\src\\com\\zeyu\\abc3.txt");

        //写字节出去
        os.write(97);   //97 为英文字母a的ASCII码
        os.write('b');
        //os.write('泽');  会乱码，中文在utf-8中占3个字节，默认只能写出去一个字节

        byte[] bytes = "重返蓝鲸岛abc".getBytes();
        os.write(bytes);    //直接写入字节数组就没有问题
        os.write("\r\n".getBytes());    //\r\n  换行
        os.write(bytes,0,15);   //写入指定长度

        os.close();

        FileOutputStream os2 = new FileOutputStream("file_io\\src\\com\\zeyu\\abc3.txt",true);  //后面写true，追加数据，不覆盖
        os2.write(bytes);
        os2.close();
    }
}

abc3.txt内容：

字节流非常适合做一切文件的复制操作

任何文件的底层都是字节，字节流做复制，是一字不漏的转移完全部字节，只要复制后的文件格式一致就没问题!

复制案例：

将c盘的一张图片复制到d盘

package com.zeyu.exercise;

import java.io.*;

public class copyFile {
    public static void main(String[] args) throws Exception {
        InputStream is = new FileInputStream("C:\\Users\\dzy\\Pictures\\Camera Roll\\六花.jpg");  //原位置
        OutputStream os = new FileOutputStream("D:\\File\\六花\\六花.jpg"); //目标位置

        byte[] buffer = new byte[1024]; //每次1kb
        int len;    //记录读出多少
        while((len = is.read(buffer)) != -1){
            os.write(buffer,0,len); //取多少倒多少
        }

        is.close();
        os.close();
    }
}

try-catch-finally 和 try-with-resource

如果在使用完IO流之后不关闭（close），可能会导致资源泄漏和引起文件锁定等问题。所以要在使用完后关闭流
假如在执行close语句之前有语句出现异常，那么自然也不会执行close语句，也就不会关闭流了
例如：

运行结果：

可以看到System.out.println(10/0) 这句语句显然是有问题的，而代码执行到这句语句时就直接终止了，后面的语句都没有执行，也就没有关闭流。鉴于这种情况，我们可以用try-catch-finally 或 try-with-resource来解决：

try-catch-finally：

package com.zeyu.Io;

import java.io.FileOutputStream;
import java.io.IOException;

public class try_catch_finally {
    public static void main(String[] args) {
        FileOutputStream os = null;
        try {
            //创建一个字节输出流管道与目标文件接通
            os = new FileOutputStream("file_io\\src\\com\\zeyu\\abc3.txt");

            //写字节出去
            os.write(97);
            os.write('b');
            //os.write('泽');  会乱码，中文在utf-8中占3个字节，默认只能写出去一个字节

            byte[] bytes = "重返蓝鲸岛abc".getBytes();
            os.write(bytes);    //直接写入字节数组就没有问题
            os.write("\r\n".getBytes());    //\r\n  换行
            os.write(bytes,0,15);   //写入指定长度
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源的操作
            try {
                if(os != null) os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

在try-catch-finally中无论代码是否报错，它都会在结束之前执行finally里面的语句，除非在其它地方使用System.exit()关闭了jvm，所以使用try-catch-finally方式是肯定会释放资源执行close的

注意：finally中不要写return语句，不然它先执行finally的return从而忽略真正的return语句

try-with-resource:

package com.zeyu.Io;

import java.io.FileOutputStream;
import java.io.IOException;

public class try_with_resource {
    public static void main(String[] args) {
        try(    //自动关闭在此创建的资源对象，调用其close方法
                //创建一个字节输出流管道与目标文件接通
                FileOutputStream os = new FileOutputStream("file_io\\src\\com\\zeyu\\abc3.txt");
                //注意：这里只能放资源对象
                //资源对象就是会实现AutoCloseable接口的对象
                ) {

            //写字节出去
            os.write(97);
            os.write('b');
            //os.write('泽');  会乱码，中文在utf-8中占3个字节，默认只能写出去一个字节

            byte[] bytes = "重返蓝鲸岛abc".getBytes();
            os.write(bytes);    //直接写入字节数组就没有问题
            os.write("\r\n".getBytes());    //\r\n  换行
            os.write(bytes,0,15);   //写入指定长度

            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

显然，这是一种比try-catch-finally更方便的方法，只要在try后面加个括号，里面写上需要释放的资源的定义语句，那么它就会自动释放其中的资源

字符流

1、FileReader(文件字符输入流)

作用:以内存为基准，可以把文件中的数据以字符的形式读入到内存中去

代码演示：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;

public class IO_charTest1 {
    public static void main(String[] args) {
        try (   // 1、创建一个文件字符输入流管道与源文件接通
                Reader r = new FileReader("file_io\\src\\com\\zeyu\\z.txt");
                ){
            //读取文本文件内容
            //每次读取一个字符(性能较差,每次读取都要进行系统调用)
//            int c;
//            while((c = r.read()) != -1){
//                System.out.print((char)c);
//            }

            //每次读取多个字符
            //性能不错（每次读取多个，进行系统调用的次数就少了）
            int len;
            char[] buffer = new char[3];
            while((len = r.read(buffer)) != -1){
                System.out.print(new String(buffer,0,len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

运行结果：

2、FileWriter(文件字符输出流)

作用:以内存为基准，把内存中的数据以字符的形式写出到文件中去

字特输出流使用时的注意事项

字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效

代码演示：

import java.io.FileWriter;
import java.io.Writer;

public class IO_charTest2 {
    public static void main(String[] args) {
        try (   // 0、创建一个文件字符输出流管道与目标文件接通。
                Writer w = new FileWriter("file_io\\src\\com\\zeyu\\z2.txt"/*,true*/);  //后面加true写入由覆盖变为追加
                ){
            // 1、public void write(int c):写一个字符出去
            w.write('l');
            // 2、public void write(string c)写一个字符串出去
            w.write("ove");
            w.write("\r\n");    //换行
            // 3、public void write(string c,int pos ,int len):写字符串的一部分出去
            w.write("hate you",5,3);
            w.write("\r\n");

            // 4、public void write(char[] buffer):写一个字符数组出去
            char[] buffer = {'当','花','叶','呢','喃','之','时','，','请','呼','唤','我','的','名','字'};
            w.write(buffer);
            w.write("\r\n");
            //5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
            w.write(buffer,8,7);
            w.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：

字节流、字符流的使用场景小结:

字节流适合做一切文件数据的拷贝(音视频，文本);字节流不适合读取中文内容输出
字符流适合做文本文件的操作(读，写)

缓冲流

对原始流进行包装，以提高原始流读写数据的性能的流
提高字节流读写数据的性能
原理:字节缓冲输入流自带了8KB缓冲池;字节缓冲输出流也自带了8KB缓冲池

构造器：

将字节流包装成字节缓冲流，再使用字节缓冲流做操作效率会更快

代码演示：

package com.zeyu.IO_byte_buffer;

import java.io.*;

public class IO_byte_bufferTest1 {
    public static void main(String[] args) {
        try (
                OutputStream os = new FileOutputStream("file_io\\src\\com\\zeyu\\b.txt");
                OutputStream bos = new BufferedOutputStream(os/*,8192*2*/);    //字节缓冲输出流，可以在后面自定义缓冲池大小
                InputStream is = new FileInputStream("file_io\\src\\com\\zeyu\\b.txt");
                InputStream bis = new BufferedInputStream(is/*,8192*/);  //字节缓冲输入流，可以在后面自定义缓冲池大小
                ){
            bos.write("由此开启那飘零于时间里的故事".getBytes());
            bos.flush();
            byte[] buffer = new byte[1024];
            int len;
            while((len = bis.read(buffer)) != -1){
                System.out.println(new String(buffer,0,len));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

运行结果：

BufferedReader(字符缓冲输入流)

作用:自带8K(8192)的字符缓冲池，可以提高字符输入流读取字符数据的性能

字符缓冲输入流新增的功能:按照行读取字符

代码演示：

package com.zeyu.IO_char;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;

public class IO_charTest1 {
    public static void main(String[] args) {
        try (   // 1、创建一个文件字符输入流管道与源文件接通
                Reader r = new FileReader("file_io\\src\\com\\zeyu\\z.txt");
                ){
            //读取文本文件内容
            //每次读取一个字符(性能较差,每次读取都要进行系统调用)
//            int c;
//            while((c = r.read()) != -1){
//                System.out.print((char)c);
//            }

            //每次读取多个字符
            //性能不错（每次读取多个，进行系统调用的次数就少了）
            int len;
            char[] buffer = new char[3];
            while((len = r.read(buffer)) != -1){
                System.out.print(new String(buffer,0,len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

运行结果：

BufferedWriter(字符缓冲输出流)

作用:自带8K的字符缓冲池，可以提高字符输出流写字符数据的性能

字符缓冲输出流新增的功能:换行

代码演示：

package com.zeyu.IO_char;

import java.io.FileWriter;
import java.io.Writer;

public class IO_charTest2 {
    public static void main(String[] args) {
        try (   // 0、创建一个文件字符输出流管道与目标文件接通。
                Writer w = new FileWriter("file_io\\src\\com\\zeyu\\z2.txt"/*,true*/);  //后面加true写入由覆盖变为追加
                ){
            // 1、public void write(int c):写一个字符出去
            w.write('l');
            // 2、public void write(string c)写一个字符串出去
            w.write("ove");
            w.write("\r\n");    //换行
            // 3、public void write(string c,int pos ,int len):写字符串的一部分出去
            w.write("hate you",5,3);
            w.write("\r\n");

            // 4、public void write(char[] buffer):写一个字符数组出去
            char[] buffer = {'当','花','叶','呢','喃','之','时','，','请','呼','唤','我','的','名','字'};
            w.write(buffer);
            w.write("\r\n");
            //5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
            w.write(buffer,8,7);
            w.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：

不同编码读取出现乱码的问题

如果代码编码和被读取的文本文件的编码是一致的，使用字符流读取文本文件时不会出现乱码!
如果代码编码和被读取的文本文件的编码是不一致的，使用字符流读取文本文件时就会出现乱码！

转换流

InputStreamReader(字符输入转换流)

解决不同编码时，字符流读取文本内容乱码的问题
解决思路:先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了

代码演示：

c.txt为GBK编码

import java.io.*;

public class IO_transFromTest1 {
    public static void main(String[] args) {
        try (
                //1、得到文件的原始字节流（GBK的字节流形式）
                InputStream is = new FileInputStream("file_io\\src\\com\\zeyu\\c.txt");
                //2、把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader isr = new InputStreamReader(is,"GBK");
                //把字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(isr);
                ){
            String line;
            while((line = br.readLine()) != null){
                System.out.println(line);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

OutputStreamWriter字符输出转换流

作用:可以控制写出去的字符使用什么字符集编码
解决思路:获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了

代码演示：

package com.zeyu.transfrom;

import java.io.*;

public class IO_transFromTest2 {
    public static void main(String[] args) {
        try (
                //1、得到文件的原始字节流（GBK的字节流形式）
                OutputStream os = new FileOutputStream("file_io\\src\\com\\zeyu\\c2.txt");
                //2、把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Writer osr = new OutputStreamWriter(os,"GBK");
                //把字符输入流包装成缓冲字符输入流
                BufferedWriter bw = new BufferedWriter(osr);
                ){
            osr.write("I’m a little used to calling outside your name\n" +
                    "我有些习惯在外面大喊你的名字");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

运行结果：

c2.txt为GBK编码

也可调用String提供的getBytes方法控制写出去的字符使用什么字符集编码

打印流

PrintStream/PrintWriter(打印流)

作用:打印流可以实现更方便、更高效的打印数据出去，能实现打印啥出去就是啥出去

Printstream提供的打印数据的方案

PrintWriter提供的打印数据的方案

演示代码：

package com.zeyu.print;

import java.io.PrintStream;

public class IO_printTest1 {
    public static void main(String[] args) {
        try (
                PrintStream ps = new PrintStream("file_io\\src\\com\\zeyu\\print.txt"/*, Charset.forName("GBK")*/); //指定字符集编码写入
//                PrintWriter ps = new PrintWriter("file_io\\src\\com\\zeyu\\print.txt"/*, Charset.forName("GBK")*/);
                                    //打印与PrintStream基本一致，PrintStream支持写字节数据，PrintWriter支持写字符数据
//                PrintWriter ps = new PrintWriter(new FileWriter("file_io\\src\\com\\zeyu\\print.txt",true));  //追加写法
                ){
            ps.println("如果下摆湿掉了的话");
            ps.println("等待干就行了");
            ps.println("水滴飞溅 发出声音");
            ps.println("是你教会了我 不再去害怕");
            ps.println("紧握住你的手 不放开的话");
            ps.println(97);
            ps.println(false);
            ps.println(3.14);
            ps.write(97);   //'a'
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

PrintStream和PrintWriter的区别

打印数据的功能上是一模一样的:都是使用方便，性能高效(核心优势)
PrintStream继承自字节输出流OutputStream，因此支持写字节数据的方法
PrintWriter继承自字符输出流Writer，因此支持写字符数据出去

打印流的一种应用:输出语句的重定向

可以把输出语句的打印位置改到某个文件中去

代码演示：

package com.zeyu.print;

import java.io.PrintStream;

public class IO_printTest2 {
    public static void main(String[] args) {
        System.out.println("如果下摆湿掉了的话");
        System.out.println("等待干就行了");
        try (
                PrintStream ps = new PrintStream("file_io\\src\\com\\zeyu\\print2.txt");
                ){
            System.setOut(ps);  //把系统默认的打印流对象改成自己的打印流对象
            System.out.println("水滴飞溅 发出声音");
            System.out.println("是你教会了我 不再去害怕");
            System.out.println("紧握住你的手 不放开的话");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

数据流

DataOutputstream(数据输出流)

允许把数据和其类型一并写出去

代码演示：

import java.io.DataOutputStream;
import java.io.FileOutputStream;

public class IO_DataOutputTest1 {
    public static void main(String[] args) {
        try (   //创建一个数据输出流包装低级的字节输出流
                DataOutputStream dos = new DataOutputStream(new FileOutputStream("file_io\\src\\com\\zeyu\\data.txt"));
                ){
            dos.writeBoolean(true);
            dos.writeInt(777);
            dos.writeDouble(3.14);
            dos.writeUTF("缠住吻住春风吹住我吗");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

Datalnputstream(数据输入流)

用于读取数据输出流写出去的数据

代码演示：

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class IO_DataInputTest2 {
    public static void main(String[] args) {
        try (        //创建一个数据输入流包装低级的字节输入流
                DataInputStream dis = new DataInputStream(new FileInputStream("file_io\\src\\com\\zeyu\\data.txt"));
                ){
            //读取的类型顺序要和写入的类型顺序一一对应，不然会出bug
            System.out.println(dis.readBoolean());
            System.out.println(dis.readInt());
            System.out.println(dis.readDouble());
            System.out.println(dis.readUTF());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

序列化流

对象序列化:把Java对象写入到文件中去
对象反序列化:把文件里的Java对象读出来

Objectoutputstream(对象字节输出流)

可以把Java对象进行序列化:把Java对象存入到文件中去

注意:对象如果要参与序列化，必须实现序列化接口(java.io.Serializable）

代码演示：

package com.zeyu.object;

import java.io.*;

public class IO_objectOutputTest1 {
    public static void main(String[] args) {
        try (   //2、创建一个对象字节输出流包装原始的字节输出流
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("file_io\\src\\com\\zeyu\\Object.txt"));
                ){
            //1、创建一个java对象
            User u1 = new User("admin","小白","123456",22);

            //3、序列化对象到文件中
            oos.writeObject(u1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

Objectlnputstream(对象字节输入流)

可以把Java对象进行反序列化:把存储在文件中的Java对象读入到内存中来

代码演示：

package com.zeyu.object;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class IO_ObjectInputTest2 {
    public static void main(String[] args) {
        try (
                //创建一个对象字节输入流管道，包装低级的字节输入流与源文件接通
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("file_io\\src\\com\\zeyu\\Object.txt"));
                ){
            User u = (User) ois.readObject();
            System.out.println(u);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

如果想让对象某个成员变量不参与序列化，可以使用transient

如果想要一次性序列化多个对象，可以用集合包装这些对象，然后直接序列化集合对象，ArrayList集合已经实现了序列化接口!

A泽予

关注

29
点赞
踩
20

收藏

觉得还不错? 一键收藏
打赏
0
评论
IO流：字节流、字符流、缓冲流、转换流、数据流、序列化流 --Java学习笔记

在try-catch-finally中无论代码是否报错，它都会在结束之前执行finally里面的语句，除非在其它地方使用System.exit()关闭了jvm，所以使用try-catch-finally方式是肯定会释放资源执行close的。即使每次读取三个字节，依旧无法避免乱码的可能，因为若读取的字符串排列为前面俩个英文接一个中文，就会读取到前面俩个英文的（英文数字在utf-8中占一个字节）字节和中文的其中一个字节。自带8K(8192)的字符缓冲池，可以提高字符输入流读取字符数据的性能。
复制链接

扫一扫