javaSE I/O流（二）—— 各种各样的流

1. FileReader和FileWriter进行字符流的处理：文本文件（.txt，.java，.c，.cpp）。不可以实现非文本文件的复制。

2. FileInputStream和FileOutputStream进行字节流的处理：非文本本（jpg,png,mp3,

mp4,doc,ppt）。但是可以实现文本文件的复制。

2.1 FileReader

1、 FileReader类记忆点

为了保证close操作一定执行，需要使用try-catch-finally
读入的文件一定要存在。不然在调用new FileReader的时候会报“FileNotFound”异常

2、 FileReader类常用方法

（1）构造方法

可以用File类的对象

FileReader fr = new FileReader(file);

也可以直接用文件路径

FileReader fr = new FileReader("hello.txt");

（2）int read（）

一次只能读一个字符，直接作为返回值返回。

注意：返回的不是char类型，而是char对应的int。返回值-1时，表示读到文件末尾

（3）int read(char [])

一次读多个字符，读入到char[] 数组中

注意：返回的依然是int类型“每次实际读出的个数”。返回值-1时，表示读到文件末尾

（4）close

3、int read()一次读一个字符操作演示

首先，我们在对应的Module下建立一个hello.txt文件，输入内容“hello world!!!”。


    @Test
    public void test01() throws IOException {
        //1)创建File对象
        File file = new File("hello.txt");
 
        //2)创建FileReader对象
        FileReader fr = new FileReader(file);
 
        //3) 读文件
        int data;  
        while((data = fr.read()) !=-1){
            System.out.print((char)data);
        }
 
        //4）关闭流
        fr.close();
    }

运行结果：

hello world!!!

但这个代码当中存在一些问题，需要优化一下：

现在是在整个函数外抛出异常，如果我的read函数出错了，那么程序中止，会导致前面打开的流没有close。换句话说，close操作是必须要执行的，那就用try-catch-finally语句。

1）选中要被try包含的代码，按住快捷键Ctrl+Alt+t，选中“try/catch/finally”

2）由于close本身也需要做异常处理。所以close也要用try-catch包起来。

3）这里还有一个问题。如果不是在read处出错，而是在new FileReader的时候就出错了，fr没有创建成功，那么进入finally的fr.close（）时，会出现“空指针异常”。所以我们在进行close操作的时候要先判断fr是不是空指针

优化后的完整代码：


@Test
    public void test01() {
        FileReader fr = null;
        try {
            //1)创建File对象
            File file = new File("hello.txt");
 
            //2)创建FileReader对象
            fr = new FileReader(file);
 
            //3) 读文件
            int data;
            while((data = fr.read()) != -1){
                System.out.println((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4）关闭流
            try {
                if(fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
 
 
    }

4、一次读多个字符int read(char[] ) 操作演示

难点：错误写法那里，不能用buf.length，而要用len。


  @Test
    public void test02(){
        FileReader fr = null;
        try {
            //1)创建File对象
            File file = new File("hello.txt");
 
            //2）创建FileReader对象
            fr = new FileReader(file);
 
            //3）读文件
            char []buf = new char[5];
            int len;
            while((len = fr.read(buf))!= -1){
                /*------输出方式（一）------*/
                //错误写法
//                for(int i=0; i
//                    System.out.println(buf[i]);
//                }
                for(int i=0; i
                    System.out.print(buf[i]);
                }
                /*-----输出方式（二）------*/
                //错误写法
//                String string = new String(buf);
//                System.out.println(string);
                String string1 = new String(buf, 0, len);
                System.out.println(string1);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4）关闭文件
            try {
                if(fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

2.2 FileWriter

2.2.1 FileWriter类的记忆点

为了保证close操作一定执行，需要使用try-catch-finally
输出的文件可以不存在。不存在的话会自动创建
“append追加”还是覆盖

2.2.2 FileWriter类的常用方法

（1）构造方法


fw = new FileWriter(file, true); //true为追加
 
fw = new FileWriter(file, false); //false为不追加
//等同于fw = new FileWriter(file);

（2）write（char）

一次写入一个字符

（3）write（char [] ）

一次写入多个字符

（4）write（String）

一次写入一个字符串

2.2.3 三个常用write（）方法的一波操作


     @Test
    public void test01(){
        FileWriter fw = null;
        try {
            //1）创建File对象
            File file = new File("notExist.txt");
 
            //2）创建FileWriter对象
            fw = new FileWriter(file, true);
 
            //3）写入操作
            fw.write('3');
            fw.write(new char[]{'S','e','p','t','e','m','b','e','r'});
            fw.write("You must find more time on this work");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4) 关闭流
            if(fw !=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

运行结果：

3SeptemberYou must find more time on this work

如果想要换行，就输入“\n”

2.3 使用FileReader和FileWriter实现文本文件的复制

模板：


        //1）创建File对象：读出和写入各一个
        
        //2）创建FileReader对象 和 FileWriter 对象
        
        //3）读出和写入操作
        
        //4）关闭两个流

完整代码


     @Test
    public void test02() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1）创建File对象：读出和写入各一个
            File readFile = new File("hello.txt");
            File writeFile = new File("notExist.txt");
 
            //2）创建FileReader对象 和 FileWriter 对象
            fr = new FileReader(readFile);
            fw = new FileWriter(writeFile, true);
 
            //3）读出和写入操作
            char []buf = new char[5];
            int len;
            while((len = fr.read(buf)) != -1){
//                //方式（一）
//                String s = new String(buf, 0, len);
//                fw.write(s);
                //方式（二）
                fw.write(buf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //4）关闭两个流
                if(fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
 
            try {
                //4）关闭两个流
                if(fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

PS：发现File类中有创建文件、删除文件，但好像并没有拷贝文件的操作。所以不能通过file.copy(源文件，目的文件)一行代码直接实现吗

那能否用FileWriter和FileReader去拷贝一张图片呢？

答：不能。

出来的bbb.jpg是打不开的。

2.4 FileInputStream

2.4.1 FileInputStream的记忆点

1.如果用FileReader以Byte[]数组的形式去读txt文本文件会怎样？

读英文和数字正常，中文会出现乱码。

英文和数字：因为我们使用的是UTF-8编码，英文和数字刚好占一字节，所以不会出现乱

中文：在UTF-8编码中占3个字节，一个一个字节去读就会把一个汉字给拆开，出现乱码。

PS：但是现在JDK的版本已经直接不支持read函数去读Byte[]了，只能读char[]。

2. 读的文件必须存在，否则会报FileNotFoundException异常

2.4.2 FileInputStream的常用函数

和FileReader一样，把char变成byte

2.5 FileOutputStream

和FileWriter一样，把char变成byte

2.6 FileInputStream和FileOutputStream实现图片的复制

因为我们在单元测试中进行，所以把要拷贝的图片放在对应的模块目录下，而不是项目目录下。


     @Test
    public void test01() throws IOException {
        FileInputStream fi = null;
        FileOutputStream fo = null;
        try {
            //1)创建File对象
            File file1 = new File("053.png");
            File file2 = new File("053-1.png");
 
            //2）创建FileInputStream和FileOutputStream对象
            fi = new FileInputStream(file1);
            fo = new FileOutputStream(file2);
 
            //3)读和写操作
            byte []buf = new byte[5];
            int len;
            while((len = fi.read(buf)) != -1){
                fo.write(buf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4)关闭流
            if(fi != null){
                try {
                    fi.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fo != null){
                try {
                    fo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

复制成功！

那能否实现（带有中文）文本文件的复制？

能。

所以再说一遍我们的结论：

1. FileReader和FileWriter进行字符流的处理：文本文件（.txt，.java，.c，.cpp）。不可以实现非文本文件的复制。

2. FileInputStream和FileOutputStream进行字节流的处理：非文本本（jpg,png,mp3,

mp4,doc,ppt）。但是可以实现文本文件的复制。

三、缓冲流

记忆点：

处理流的一种。
作用：提高文件的读写效率。
开发的时候我们不会用FileReader、FileWriter、FileInputStream和FileOutputStream。因为他们的效率太慢了。
四种
装饰者模式，增加了readLine方法
关闭外层流时自动关闭内层流

因为缓冲流的操作和前面的四个节点流差不多，所以就不单独介绍四个Buffered类了。直接上操作

3.1 BufferedInputStream类

和FileInputStream一样

3.2 BufferedOutputStream类

和FileOutputStream一样

3.3 BufferedInputStream和BufferedOutputStream实现非文本文件的复制

两个注意点：

1. 前面我们知道，处理流是包在节点流的外面的。所以new处理流之前要先new对应的结点流，并且节点流的对象作为处理流构造函数的参数。

2. 相应的，关闭流的时候我们也应该关闭节点流和处理流。按照“先关闭外层的流再关闭内层的流”原则（和“创建析构顺序”，“穿衣脱衣顺序”同理），应该先关闭处理流的两个流，再关闭节点流的两个流。但是这里外层流自动关闭内层流，所以我们只需要关闭外层处理流就可以了。


     @Test
    public void test01(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1)创建File对象
            File srcFile = new File("053.png");
            File desFile = new File("053-2.png");
 
            //2)创建节点流对象和处理流对象
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(desFile);
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
 
            //3)读 和 写
            byte []buf = new byte[10];
            int len;
            while((len = bis.read(buf)) != -1){
                bos.write(buf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4)关闭流 :只需要关闭外层流就可以了。外层流自动关闭内层流
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

为什么用BufferedInputStream、BufferedOutputStream对文件进行处理比FileInputStream和FileOutputStream快得多？

操作系统笔记——缓冲区管理_玛丽莲茼蒿的博客-CSDN博客

和缓冲区的原理一样。文件在磁盘上，磁盘是一种I/O设备，写文件就是写I/O设备。在缓冲区（其实就是在内存开辟一块地方）这个定义出现之前，CPU和I/O设备是直接交互的（这里可以理解为程序和文件是直接交互的），但是CPU和I/O设备的速度差太大了啊，I/O完全是在拖后腿！有了缓冲区之后：

注意：当缓冲区为空时，可以往缓冲区冲入数据，但是必须充满以后才能传出；当缓冲区数据非空时，不能往缓冲区冲入数据，只能从缓冲区把数据传出；如此就不会频繁地“写-读-写-读”，而是“写写写写——一次性读走”

因为Bufferd在内存里定义了一个缓冲区。这个缓冲区的大小=8×1024=8192个字节。当这个缓冲区被填满以后，会自动调用一个flush(）方法，把缓冲区的内容一次性写到磁盘里。而不是读一次文件接着写一次磁盘。

3.4 BufferedReader类

和FileReader类不同的是，多了一个新方法

readLine（）：一次读一行返回String类型，读到末尾返回null。但是该函数读不出来换行符。

3.5 BufferedWriter类

和FileWriter一样。

3.6 BufferedReader和BufferedWriter实现文本文件的复制


    @Test
    public void test02(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //1）和2）合并
            br = new BufferedReader(new FileReader(new File("hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("hello-1.txt")));
 
            //3)读 写
            int len;
            char []cbuf = new char[1024];
            while((len = br.read(cbuf)) != -1){
                bw.write(cbuf, 0,len);
            }
 
            //法（二）
            String data;
            while((data = br.readLine()) != null){
                bw.write(data+'\n'); //加换行符是因为readLine读不出换行符，所以要手动加上
            }
 
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4)关闭流
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

3.7 练习题

1. 图片加密存储、解密显示

加密的方法很简单，让图片的每个byte和一个数做异或操作，得到的加密图片和原图大小一样

解密：由于两次异或同一个数等于本身，即“m ^ n ^ n = m”，解密操作和加密是一样的，也是和5做异或。

2. 获取文本文件里每个字符出现的个数。


        BufferedReader reader = null;
        HashMap hashMap = null;
        try {
            //1）创建Map对象
            hashMap = new HashMap();
 
            //2）创建BufferedReader对象
            reader = new BufferedReader(new FileReader(new File("hello.txt")));
 
            //3）读 和 统计
            int c = 0;
            while((c = reader.read()) != -1){
                char c2 = (char) c;
                if(hashMap.get(c2) != null){
                    hashMap.put(c2,hashMap.get(c2)+1);
                }else{
                    hashMap.put(c2,1);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(reader != null){
                try {
                    //4）关闭流
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //输出结果
        System.out.println(hashMap);

还可以用read(char [])替代read（）。还可以用contasinsKey()替代get检查字符是否出现过。

四、转换流

4.1 记忆点

1.InputStreamReader和OutputStreamWriter的作用

记下面这张图就行了

InputStreamReader：把【输入的字节流】转换成【输入的字符流】；把看不懂的变成看得懂的，解码

OutputStreamWriter:把【输出的字符流】转换成【输出的字节流】；反之，编码

2. InputStreamReader和OutputStreamWriter属于抽象基类InputStream和OuputStream还是Reader和Writer？

属于Reader和Writer这两个抽象基类的实现类————是谁的实现类只看后缀

3.什么时候用？

需要进行字符流和字节流之间转换时，简单说，涉及到编码时。

4.2 InputStreamReader常用函数

构造函数

第二个参数：所读文件“utf-8.txt”保存时的编码方式


InputStreamReader reader = new InputStreamReader(节点流对象, "UTF-8");
 
//如果构造函数的第二个参数不写，默认采用IDEA的编码方式去解码
InputStreamReader reader = new InputStreamReader(节点流对象);

4.3 InputStreamReader用法

为了便于看，我们就不用try-catch-finnaly了


    @Test
    public void test01() throws IOException {
        //1)不用创建File对象了，直接创建FileInputStream和InputStreamReader对象
        FileInputStream fis = new FileInputStream("hello.txt");
        InputStreamReader reader = new InputStreamReader(fis, "UTF-8");
        
        //2)读，然后输出到命令行看看
        char []cbuf = new char[5];
        int len=0;
        while((len = reader.read(cbuf)) != -1){
            System.out.println(new String(cbuf,0,len));
        }
        
        //3)关闭流
        reader.close();
    }

上面这个hello.txt是用UTF-8保存的文件，我们试着用gbk去解码看看：

4.4 OutputStreamWriter常用函数

构造函数

第二个参数：指定用什么方式编码

        OutputStreamWriter writer = new OutputStreamWriter(节点流对象, "gbk");

4.5 OutputStreamWriter用法

我们用FileReader读一个utf-8编码的文件“hello.txt”，然后用转换流对其重新编码，以"gbk"方式存储。


     @Test
    public void test02() throws IOException {
        //1)以字符的方式读文件，以转换流的方式对文件重新编码写文件
        FileReader reader = new FileReader("hello.txt");
 
        FileOutputStream fos = new FileOutputStream("gbk.txt");
        OutputStreamWriter writer = new OutputStreamWriter(fos, "gbk");
 
        //2)读文件 写文件
        char []cbuf = new char[5];
        int len = 0;
        while((len = reader.read(cbuf)) != -1){
            writer.write(cbuf,0,len);
        }
 
        //3)关闭流
        reader.close();
        writer.close();
    }

接下来讲的三个流稍作了解：

标准输入流、标准输出流
打印流
数据流

五、标准输入流System.in、标准输出流System.out

5.1 记忆点

1. System.in：默认从键盘输入。System.out 默认从显示器输出。可以通过System类的setIn（）和setOut（）方法更改默认的输出端

2. System.in和System.out是字节流！！！想一下也不可能是字符流，怎么可能只向显示器输出字符呢？

5.2 常用方法

最常用的不就是我们的


System.out.print();
System.out.println();

5.3 例题

这里我们用方法二，因为我们想用BufferdReader的readline方法，但是BufferdReader读的是字符流，而system.in是字节流。这时候就要想到字节流向字符流的转换——转换流。

PS:因为IDEA的限制，system.in在单元测试下没法通过键盘输入，所以我们写在main函数里。同时，为了方便看程序的逻辑，这里也没用try-catch-finally，而是直接抛的异常


    public static void main(String[] args) throws IOException {
        //1)转换流把标准输入的字节流变成字符流
        InputStreamReader charReader = new InputStreamReader(System.in);
        //再包上一层Buffer处理流
        BufferedReader reader = new BufferedReader(charReader);
 
        //2)读
        while(true){
            String data = reader.readLine();
            if("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)){
                System.out.println("程序结束");
                break;
            }
            System.out.println(data.toUpperCase());
        }
 
        //关闭流
        reader.close();
    }

六、打印流——printStream和printWriter

printStream：字节输出流

printWriter：字符输出流

如果程序的结果不想往控制台输出，想输入到一个文件里。就用打印流指定文件的位置，然后用System的静态方法setOut去设置默认的输出端。

七、数据流——DataInputStream、DataOutputStream

注意：DataOutputStream写到文件去的基本数据类型不能直接打开看，而只能通过DataInputStream读到内存中去看

八、对象流—— ObjectInputStream、ObjectOutputStream

8.1 记忆点

（1）通过后缀可以看出，对象流本质上是字节流

（2）ObjectOutputStream实现对象的序列化：可以把java中的对象写入到磁盘的数据源（文件、数据库）中（目的是为了将java对象存储下来，因为程序运行结束后内存中创建的java对象也就消失了，要想留下Java对象，就要存储到到磁盘中），或者通过网络将这种二进制流从一个网络结点传输到另一个网络结点。

ObjectInputStream实现对象的反序列化：将二进制流恢复成java对象

（3）基本数据类型和String、Data、File、TreeSet等java常用类可以直接序列化。但是我们自定义的类的对象要实现序列化需要满足以下3点要求：

自定义类要实现Serializable接口。Serializable接口是一个“标识接口”，里面没有任何方法。
在类内提供一个静态常量serialVersionUID（随便给一个long型的数，正负都行）

private(public) static final long serialVersionUID = 665132135465L;

对象的所有属性都要可序列化

（4）类中被static和transient修饰的属性无法序列化。

（5）实际开发的中进行两个进程间数据传输的时候，我们一般不把类进行序列化，而是将类转换成JSON字符串，直接传送JSON字符串。

8.2 常用方法

8.2.1 ObjectOutputStream类

1.将对象序列化

writeObject(java对象)

2.刷新到硬盘上去

void flush(); //刷新

8.2.2 ObjectInputStream类

1. 将对象反序列化

Object readObject();

8.3 栗子

test01将Person类的对象进行序列化，test02进行反序列化，先运行test01，再运行test02。


 /**
     * ObjectOutputStream进行序列化
     */
    @Test
    public void test01(){
        //1)
        ObjectOutputStream oos = null; //写入txt文件也可以，但是写入的文件不能打开看
        try {
            oos = new ObjectOutputStream(new FileOutputStream("Object.data"));
 
            //2）写
            oos.writeObject(new Person("程野",15));
            oos.writeObject(new Person("王小虎",16));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(oos != null){
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    /**
     * ObjectInputStream进行反序列化
     */
    @Test
    public void test02(){
        ObjectInputStream ois = null;
        try {
            //1)
            ois = new ObjectInputStream(new FileInputStream("Object.data"));
 
            //2)读
            Object o = ois.readObject();
            System.out.println(o.toString());
 
            Object o1 = ois.readObject();
            System.out.println(o1.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

结果如下：

Person{name='程野', age=15}
Person{name='王小虎', age=16}

注意：

1）和数据流一样，对象流的数据源“Object.data”也不能打开看，只能通过ObjectInputStream读进内存后才能看。

2）先写入的对象先读出

以上的例子是发送端把序列化的对象存在本地文件中，接收端再去读取这个文件。那如果是网络传输呢？比如我们想要通过UDP实现对象的传输。如果还采用“存储到文件”的方法，就需要再把文件转换成byte[]字符数组。像下面这样，很麻烦的，其实是多此一举。

有没有其他办法呢？其实可以借助ByteArrayOutputStream，直接把对象序列化到byte[]数组中，这样就省去了“本地文件”转换这一步。


package UDP;
 
import org.junit.Test;
 
import java.io.*;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
 
public class UDPtest2 {
 
    @Test
    public void send() throws IOException {
        //1.创建一个数据报套接字对象
        DatagramSocket socket = new DatagramSocket();
 
        //2.将person对象序列化，序列化的结果存放在data[]中，
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(new Person("2022/11/21",22));
        byte [] data = bos.toByteArray();
 
        //3.生成UDP数据报
        DatagramPacket packet = new DatagramPacket(data,0, data.length, InetAddress.getLocalHost(),5566);
 
        //3.套接字发送数据报
        socket.send(packet);
 
        //4.关闭资源
        socket.close();
    }
 
    @Test
    public void receive() throws IOException, ClassNotFoundException {
        //1.创建服务器端的套接字对象
        DatagramSocket socket = new DatagramSocket(5566);
 
        //2.创建服务器端的数据报对象
        byte []data = new byte[1024];
        DatagramPacket packet = new DatagramPacket(data, 0, data.length);
 
        //3.套接字接收数据报
        socket.receive(packet);
 
        ByteArrayInputStream bis = new ByteArrayInputStream(packet.getData());
        ObjectInputStream ois = new ObjectInputStream(bis);
        Object o = ois.readObject();
        Person p = (Person) o;
        System.out.println(p.getName());
        System.out.println(p.getAge());
 
        //4. 关闭资源
        socket.close();
    }
}
 
class  Person implements Serializable{
    private String name;
    private int age;
 
    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;
    }
}

运行结果：

2022/11/21
22

8.4 自定义类可序列化的3个条件

自定义类要实现Serializable接口。Serializable接口是一个“标识接口”，里面没有任何方法。
在类内提供一个静态常量serialVersionUID（随便给一个long型的数，正负都行）

private(public) static final long serialVersionUID = 665132135465L;

对象的所有属性可序列化

问题（一）：那为什么java常用类可以直接序列化呢？原因很简单，因为他们在实现的时候已经满足上述两个要求，比如以File类为例：

问题（二）：静态常量serialVersionUID的作用。

识别java对象。老师举了一个“哆啦A梦任意门”的例子很形象。进任意门的时候就是序列化的过程，人被打碎成“二进制流”才能传递，出任意门的时候就是反序列化的过程，二进制流又转换成人。如果有人、猪、狗同时通过任意门传递，那我们怎么知道这一段二进制流应该恢复成人还是猪还是狗呢？就是通过serialVersionUID去判断

问题（三）：当我们自定义的类实现Serializable接口后，即使我们不去显示地定义静态常量serialVersionUID，java也会帮我们自动生成。那为什么我们还要显式定义呢？

因为一旦我们对Person进行修改，如果UID是自动生成的话，UID也会自动修改。在下面这种情况下会出错：我们已经序列化了Person类的对象，它携带着UID1，在反序列化之前，我们对Person的代码进行了改动，现在Person类的UID变成了UID2，现在进行反序列化，发现找不到UID1对应的Person类了。

现在解释第三个条件。在上面的例子中，因为我们的Person类的属性只有基本数据类型和java常用类String，Person的对象自然可以序列化。现在，我们给Person类添加一个Arm属性。


class Arm{
}

此时我们再去序列化

异常会直接提醒我们，Arm不可以序列化

所以，Arm类也要实现Serializable接口

此外，还要注意的是，可不可以序列化看的是这个对象携带了什么属性。如果类中有Arm属性，但是对象在实例化的时候并没有Arm属性，还是可以实例化的。

那么该对象是可以实例化的


            oos.writeObject(new Person("程野",15));
            oos.writeObject(new Person("王小虎",16));

8.5 被static和transient修饰的属性无法序列化

还是Person的例子，我们将age属性设为static

然后进行序列化

反序列化的结果：

可以这样理解，如果Person类在进行时空穿梭前，将胳膊这一属性定义为static，那么穿梭后恢复的人没有胳膊。

八、序列化详解

以上介绍的实现Serializable接口是JDK自带的序列化方式，但是JDK 自带的序列化方式一般不会用，因为序列化效率低并且存在安全问题。

比较常用的序列化协议有 Kryo、Protobuf、ProtoStuff、Hessian，这些都是基于二进制的序列化协议。还有 JSON 和 XML 这种属于文本类序列化方式（字符直接根据编码转化成二进制流在信道中传播），可读性比较好。

9、RandomAccessFile类

9.1 记忆点

（1）和前面所说的各种流不一样，RandomAccessFile类直接继承于Object类，和四个基类无瓜。

（2）RandomAccessFile类自己既可以实现输入又可以实现输出。

其中写操作要注意的是，前面讲的输出流进行写文件操作时，都是“整个文件的覆盖”。比如文件原来存有“今天吃排骨”，我们写入“明天”两个字，会直接把整个文件覆盖成只有“明天”两个字。而RandomAccessFile类会把文件覆盖成“明天吃排骨”。

（3）利用seek（）方法，实现多线程断点下载。

9.2 常用方法

1. 读

read()

2. 写

从指针指到的位置开始写

write()

3. 找到文件指针

seek()

9.3 多线程断点下载

1. 浏览器下载：下载前只建立一个与被下载文件大小相同的空文件。如果下载因为网络中断，用户再次点击“开始”按钮，需要重新从头下载，而不是从断点继续下载。

那什么是断点下载呢？就是下一次下载可以从断点开始，而不是从头开始。

如何实现的呢？用一个文件指针记录断点位置。

2. 下载工具：使用RandomAccessFile类实现多线程断点下载，这也是下载工具更快的原因。下载前建立两个文件，一个是与被下载文件大小相同的空文件，一个是记录文件指针的位置文件。

如何实现的呢？把一个文件在逻辑上切分成4份，开4个线程同时下载。用下载文件的大小和分割的份数4可以计算出4个指针的位置，每个线程用RandomAccessFile类调用seek（）函数找到4个指针的位置，分别下载。

相关阅读:
初识网络编程
 LeetCode：746. 使用最小花费爬楼梯【动态规划】
ArcGIS笔记8_测量得到的距离单位不是米？一经度一纬度换算为多少米？
ASP.NET Core - .NET 6 的入口文件
 CRM系统可以给销售人员带来什么？
nacos鉴权报invalid username or password
git实战-多分支开发-2022新项目
 【selection】学习光标API并实现编辑区插入表情图片的功能
 Kotlin的关键字 lateinit 和 lazy
C++核心编程——P36-友元
原文地址：https://blog.csdn.net/qq_44886213/article/details/126918085

javaSE I/O流（二）—— 各种各样的流

一、Java IO

3. 一般I/O有两种

4. 流的分类

5. IO流的体系

6、在Main函数中和Test单元测试中，文件路径是不同的

二、访问文件的4个节点流

2.1 FileReader

1、 FileReader类记忆点

2、 FileReader类常用方法

3、int read()一次读一个字符 操作演示

4、一次读多个字符int read(char[] ) 操作演示

2.2 FileWriter

2.2.1 FileWriter类的记忆点

2.2.2 FileWriter类的常用方法

2.2.3 三个常用write（）方法的一波操作

2.3 使用FileReader和FileWriter实现文本文件的复制

2.4 FileInputStream

2.4.1 FileInputStream的记忆点

2.4.2 FileInputStream的常用函数

2.5 FileOutputStream

2.6 FileInputStream和FileOutputStream实现图片的复制

三、缓冲流

3.1 BufferedInputStream类

3.2 BufferedOutputStream类

3.3 BufferedInputStream和BufferedOutputStream实现非文本文件的复制

3.4 BufferedReader类

3.5 BufferedWriter类

3.6 BufferedReader和BufferedWriter实现文本文件的复制

3.7 练习题

四、转换流

4.1 记忆点

4.2 InputStreamReader常用函数

4.3 InputStreamReader用法

4.4 OutputStreamWriter常用函数

4.5 OutputStreamWriter用法

五、标准输入流System.in、标准输出流System.out

5.1 记忆点

5.2 常用方法

5.3 例题

六、打印流——printStream和printWriter

七、数据流——DataInputStream、DataOutputStream

八、对象流—— ObjectInputStream、ObjectOutputStream

8.1 记忆点

8.2 常用方法

8.2.1 ObjectOutputStream类

8.2.2 ObjectInputStream类

8.3 栗子

8.4 自定义类可序列化的3个条件

8.5 被static和transient修饰的属性无法序列化

八、序列化详解

9、RandomAccessFile类

9.1 记忆点

9.2 常用方法

9.3 多线程断点下载

3、int read()一次读一个字符操作演示