JavaIO流

2023-08-04 09:49:22

JavaIO流

File类的使用

  • File类的一个对象，代表一个文件或一个文件目录（俗称：文件夹）
  • File类声明在java.io包下

如何创建File类的实例

  • public File(String pathname)

    • 以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果 pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。

      • 绝对路径：是一个固定的路径,从盘符开始
      • 相对路径：是相对于某个位置开始
    • File file1 = new File("hello.txt");  //相对于当前module
File file2 = new File("E:\\Project\\java\\IdeaProjects\\workspace_idea1\\JavaSenior\\day08\\he.txt");

  • public File(String parent,String child)

    • 以parent为父路径，child为子路径创建File对象

    • File file3 = new File("E:\\Project\\java\\IdeaProjects\\workspace_idea1","JavaSenior");

  • public File(File parent,String child)

    • 根据一个父File对象和子文件路径创建File对象

    • File file4 = new File(file3,"hi.txt");

说明：

IDEA中：

  • 如果开发使用Junit中的单元测试方法测试，相对路径即为当前Module下
  • 如果大家使用main()测试，相对路径即为当前Project下

Eclipse中：

  • 不管使用单元测试方法还是使用main()测试，相对路径都是当前的Project下。

路径分隔符

  • 路径中的每级目录之间用一个路径分隔符隔开。

  • 路径分隔符和系统有关：

    • windows和DOS系统默认使用“\”来表示
    • UNIX和URL使用“/”来表示

  • Java程序支持跨平台运行，因此路径分隔符要慎用

  • 为了解决这个隐患，File类提供了一个常量：

    • public static final String separator。根据操作系统，动态的提供分隔符。

    • File file1 = new File("d:\\atguigu\\info.txt"); 
File file2 = new File("d:" + File.separator + "atguigu" + File.separator + "info.txt"); 
File file3 = new File("d:/atguigu");

常用方法

**File类的获取功能 **

  • public String getAbsolutePath()：获取绝对路径

  • public String getPath() ：获取路径

  • public String getName() ：获取名称

  • public String getParent()：获取上层文件目录路径。若无，返回null

  • public long length() ：获取文件长度（即：字节数）。不能获取目录的长度

  • public long lastModified() ：获取最后一次的修改时间，毫秒值

    如下两个方法适用于文件目录：

  • public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组

  • public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组

代码举例一：

File file1 = new File("hello.txt");	//文件存在
File file2 = new File("C:\\Users\\17527\\Desktop\\hi.txt");	//文件不存在

//此时的调用都是内存层面的调用，不涉及硬盘层面的，所以没有文件也不会报任何错误
System.out.println(file1.getAbsolutePath());
System.out.println(file1.getPath());
System.out.println(file1.getName());
System.out.println(file1.getParent());
System.out.println(file1.length());
System.out.println(new Date(file1.lastModified()));

System.out.println("***************************");

System.out.println(file2.getAbsolutePath());
System.out.println(file2.getPath());
System.out.println(file2.getName());
System.out.println(file2.getParent());
System.out.println(file2.length());
System.out.println(file2.lastModified());

输出如下：

E:\Project\java\IdeaProjects\workspace_idea1\JavaSenior\day08\hello.txt
hello.txt
hello.txt
null
10
Tue Apr 13 15:34:13 CST 2021
***************************
C:\Users\17527\Desktop\hi.txt
C:\Users\17527\Desktop\hi.txt
hi.txt
C:\Users\17527\Desktop
0
0

代码举例二：

File file = new File("E:\\Picture");

String[] list = file.list();
for (String str: list){
    System.out.println(str);
}

File[] files = file.listFiles();
for (File f : files){
    System.out.println(f);
}

输出如下：

1607663557663.jpg
game
QQ浏览器截图
Typora
图片素材
壁纸
截图
E:\Picture\1607663557663.jpg
E:\Picture\game
E:\Picture\QQ浏览器截图
E:\Picture\Typora
E:\Picture\图片素材
E:\Picture\壁纸
E:\Picture\截图

File类的重命名功能

  • public boolean renameTo(File dest):把文件重命名为指定的文件路径

比如：file1.renameTo(file2)为例：

​ 要想保证返回true，需要file1在硬盘中是存在的，且file2不能在硬盘中存在。

File file1 = new File("hello.txt");
File file2 = new File("C:\\Users\\17527\\Desktop\\hi.txt");

boolean b = file1.renameTo(file2);
System.out.println(b);

File类的判断功能

  • public boolean isDirectory()：判断是否是文件目录
  • public boolean isFile() ：判断是否是文件
  • public boolean exists() ：判断是否存在（指硬盘中是否存在）
  • public boolean canRead() ：判断是否可读
  • public boolean canWrite() ：判断是否可写
  • public boolean isHidden() ：判断是否隐藏

File类的创建功能

  • public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
  • public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。 如果此文件目录的上层目录不存在，也不创建。
  • public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建

注意事项：如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目 路径下。

上面的三个方法是真正意义上创建文件的方法

File类的删除功能

  • public boolean delete()：删除文件或者文件夹

删除注意事项： Java中的删除不走回收站。

要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录

JavaIO流
总结：

  • File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并为涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。
  • 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的“终点”。

IO流原理及流的分类

Java IO原理

  • I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等
  • Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。
  • java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据
  • 输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
  • 输出output：将程序（内存） 数据输出到磁盘、光盘等存储设备中

流的分类

  • 按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)
  • 按数据流的流向不同分为：输入流，输出流
  • 按流的角色的不同分为：节点流，处理流

JavaIO流
JavaIO流

IO流体系

JavaIO流

分辨流看后面

读取数据（字符流）

将day09下的hello.txt文件内容读入程序中，并输出到控制台

说明点：

  1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
  2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
  3. 读入的文件一定要存在，否则就会报FileFoundException。

读取数据的规范步骤：

  1. File类的实例化
  2. FileReader流的实例化
  3. 读入的操作
  4. 资源的关闭
//对read()操作升级：使用read的重载方法
@Test
public void testFileReader1(){
    FileReader fileReader = null;
    try {
        //1.File类的实例化
        File file = new File("hello.txt");

        //2.FileReader流的实例化
        fileReader = new FileReader(file);

        //3.读入的操作
        //read(char[] cbuf)：返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
        //比如这个例子第一次读入5个，len就是5，第二次读入5个，len就是5，第三次读入3个，len就为3
        char[] cbuf = new char[5];
        int len;
        while ((len = fileReader.read(cbuf)) != -1){
            //错误的写法：
            //                for (int i = 0;i < cbuf.length;i++){
            //                    System.out.print(cbuf[i]);    //helloWorld123ld
            //                }
            //正确的写法：
            //                for (int i = 0;i < len;i++){
            //                    System.out.print(cbuf[i]);
            //                }

            //方式二：
            //错误的写法，对应着方式一的错误的写法
            //                String str = new String(cbuf);
            //                System.out.print(str);  helloWorld123ld
            //正确的写法：
            String str = new String(cbuf,0,len);
            System.out.print(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fileReader != null)
            //4.资源的关闭
        {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

写出数据（字符流）

写出数据的步骤规范：

  1. 提供File类的对象，指明写出到的文件
  2. 提供FileWriter的对象，用于数据的写出
  3. 写出的操作
  4. 流资源的关闭
@Test
public void testFileWriter() {
    FileWriter fileWriter = null;
    try {
        //1.提供File类的对象，指明写出的文件
        File file = new File("hello1.txt");

        //2.提供FileWriter的对象，用于数据的写出
        fileWriter = new FileWriter(file, true);

        //3.写出的操作
        fileWriter.write("I hava a dream!\n");
        fileWriter.write("you need to have a dream!");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fileWriter != null) {
            //4.流资源的关闭
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

说明：

  1. 输出操作，对应的File可以不存在的。并不会报异常
  2. File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
    • File对应的硬盘中的文件如果存在：
      • 如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖
      • 如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容

文件的读取与写入（复制操作）

@Test
public void testFileReaderFileWriter() {
    FileReader fileReader = null;
    FileWriter fileWriter = null;
    try {
        //1.创建File类的对象，指明读入和写出的文件
        File srcFile = new File("hello.txt");
        File descFile = new File("hello2.txt");

        //不能使用字符流来处理图片等字节数据
//        File srcFile = new File("1607663557663.jpg");
//        File descFile = new File("1607.jpg");


        //2.创建输入流和输出流的对象
        fileReader = new FileReader(srcFile);
        fileWriter = new FileWriter(descFile);

        //3.数据的读入和写出操作
        char[] cbuf = new char[5];
        int len;    //记录每次读入到cbuf数组中的字符的个数
        while ((len = fileReader.read(cbuf)) != -1) {
            //每次写出len个字符
            fileWriter.write(cbuf, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4.关闭流资源
        //方式一：
//            try {
//                if (fileReader != null)
//                    fileReader.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            } finally {
//                try {
//                    if (fileReader != null)
//                        fileWriter.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }

        //方式二：
        try {
            if (fileReader != null)
                fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            if (fileReader != null)
                fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这里注意处理两个流资源的关闭可以用两个try-catch。因为try-catch是等于真正的处理掉了异常，所以后面的代码一样会执行

字节流

实现对图片的复制操作

@Test
public void testFileInputOutoutSteam() {
    FileInputStream fileInputStream = null;
    FileOutputStream fileOutputStream = null;
    try {
        File srcFile = new File("1607663557663.jpg");
        File destFile = new File("11111111.jpg");

        fileInputStream = new FileInputStream(srcFile);
        fileOutputStream = new FileOutputStream(destFile);

        byte[] buffer = new byte[5];
        int len;
        while ((len = fileInputStream.read(buffer)) != -1) {
            fileOutputStream.write(buffer, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {

        try {
            if (fileInputStream != null)
                fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if (fileOutputStream != null)
                fileOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

指定路径下文件的复制

public void copyFile(String srcPath, String destPath) {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        //
        File srcFile = new File(srcPath);
        File destFile = new File(destPath);

        //
        fis = new FileInputStream(srcFile);
        fos = new FileOutputStream(destFile);

        //复制的过程
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
        }

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fos != null) {
            //
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fis != null) {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }


}

@Test
public void testCopyFile() {

    long start = System.currentTimeMillis();

    String srcPath = "C:\\Users\\17527\\Desktop\\不知火.mp4";
    String destPath = "C:\\Users\\17527\\Desktop\\不知火1.mp4";


//        String srcPath = "hello.txt";
//        String destPath = "hello3.txt";

    copyFile(srcPath, destPath);


    long end = System.currentTimeMillis();

    System.out.println("复制操作花费的时间为：" + (end - start));//2429

}
}

结论：

  1. 对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理
  2. 对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,…)，使用字节流处理
    • 字节流也可以来实现文本文件的复制，因为这里复制操作没有经过控制台

缓冲流（处理流的一种）

  • 为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。
    JavaIO流
    缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：

  • BufferedInputStream 和 BufferedOutputStream

  • BufferedReader 和 BufferedWriter

JavaIO流
代码举例：

public class BufferedTest {

    /*
    实现对非文本文件的复制
     */
    @Test
    public void BufferedSteamTest(){
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;

        try {
            //1.造文件
            File srcFile = new File("1607663557663.jpg");
            File destFle = new File("2222222.jpg");

            //2.造流
            //2.1 造节点流
            fileInputStream = new FileInputStream(srcFile);
            fileOutputStream = new FileOutputStream(destFle);
            //2.2 造缓冲流
            bufferedInputStream = new BufferedInputStream(fileInputStream);
            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

            //3.复制的细节：读取、写入的过程
            byte[] buffer = new byte[10];
            int len;
            while ((len = bufferedInputStream.read(buffer)) != -1){
                bufferedOutputStream.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            try {
                if(bufferedInputStream != null)
                bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bufferedOutputStream != null)
                bufferedOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略不写。
//        fileInputStream.close();
//        fileOutputStream.close();
        }
    }


    //实现文件复制的方法
    public void copyFileWithBuffered(String srcPath,String destPath){
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;

        try {
            //1.造文件
            File srcFile = new File(srcPath);
            File destFle = new File(destPath);

            //2.造流
            //2.1 造节点流
            fileInputStream = new FileInputStream(srcFile);
            fileOutputStream = new FileOutputStream(destFle);
            //2.2 造缓冲流
            bufferedInputStream = new BufferedInputStream(fileInputStream);
            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

            //3.复制的细节：读取、写入的过程
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bufferedInputStream.read(buffer)) != -1){
                bufferedOutputStream.write(buffer,0,len);

//                bufferedOutputStream.flush();//刷新缓冲区

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            try {
                if(bufferedInputStream != null)
                    bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bufferedOutputStream != null)
                    bufferedOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略不写。
//        fileInputStream.close();
//        fileOutputStream.close();

        }
    }

    @Test
    public void test(){
        long start = System.currentTimeMillis();
        copyFileWithBuffered("C:\\Users\\17527\\Desktop\\不知火.mp4","C:\\Users\\17527\\Desktop\\不知火2.mp4");
        long end = System.currentTimeMillis();
        System.out.println("花费的时间为：" + (end - start));  //652
    }


    /*
    使用BufferedReader和BuferedWriter实现文本文件的复制
     */
    @Test
    public void testBufferedReaderBufferedWriter(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("dbcp.txt")));
            bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));

            //读写操作
            //方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//            int read;
//            while ((read = br.read(cbuf)) != -1){
//                bw.write(cbuf,0,read);
//            }

            //方式二：使用String
            String data;
            while ((data = br.readLine()) !=null){  //readLine()一次读取一行数据，但是不会换行
                //方法一：
//                bw.write(data + "\n");//data中不包含换行符
                //方法二：
                bw.write(data);//data中不包含换行符
                bw.newLine();//提供换行的操作
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            //资源的关闭
            try {
                if (br != null)
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bw != null)
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }


}

readLine()：一次读取一行数据，但是不会换行—> 在BufferedReader中可用

实现图片加密操作

byte[] buffer = new byte[1024];
            int len;
            while ((len = fi.read(buffer)) != -1) {
                //字节数组进行修改
                //错误的：这里修改的是新的变量，并不会对数组进行修改
    //            for (byte b:buffer){
    //                b = (byte)(b ^ 5);
    //            }
                //正确的：
                for (int i = 0; i < len; i++) {
                    buffer[i] = (byte)(buffer[i] ^ 5);
                }
                fo.write(buffer, 0, len);

m ^ n ^ n = n，所以解密过程就是把需要解密的文件再^5（加密）一次即可

转换流（处理流的一种）

  • 转换流提供了在字节流和字符流之间的转换
  • Java API提供了两个转换流：
    • InputStreamReader：将InputStream转换为Reader
    • OutputStreamWriter：将Writer转换为OutputStream

InputStreamReader

  • 实现将字节的输入流按指定字符集转换为字符的输入流。
  • 需要和InputStream“套接”。
  • 构造器
    • public InputStreamReader(InputStream in)
    • public InputSreamReader(InputStream in,String charsetName)

OutputStreamWriter

  • 实现将字符的输出流按指定字符集转换为字节的输出流。
  • 需要和OutputStream“套接”。
  • 构造器
    • public OutputStreamWriter(OutputStream out)
    • public OutputSreamWriter(OutputStream out,String charsetName)

代码举例：

/*
此时处理异常的话，仍然应该使用try-catch-finally
InputStreamReader的使用，实现字节的输入流到字符的输入流的转换
 */
@Test
public void test1() throws IOException {
    FileInputStream fis = new FileInputStream("dbcp.txt");
//        InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集，当前为utf-8
    //参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时的字符集
    InputStreamReader isr = new InputStreamReader(fis,"UTF-8");

    char[] cbuf = new char[20];
    int len;
    while ((len = isr.read(cbuf)) != -1){
        System.out.print(new String(cbuf,0,len));
    }

    isr.close();

}

JavaIO流

/*
综合使用InputStreamReader和OutputStreamWriter
 */
@Test
public void test2() throws IOException {

    File file1 = new File("dbcp.txt");
    File file2 = new File("dbcp_gdk.txt");

    FileInputStream fis = new FileInputStream(file1);
    FileOutputStream fos = new FileOutputStream(file2);

    InputStreamReader isr = new InputStreamReader(fis,"utf-8");
    OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

    //读写过程
    char[] cbuf = new char[20];
    int len;
    while ((len = isr.read(cbuf)) != -1){
        osw.write(cbuf,0,len);
    }

    osw.close();
    isr.close();

}

对象流

  • ObjectInputStream和OjbectOutputSteam

    • 用于存储和读取基本数据类型数据或==对象==的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

  • 序列化：用ObjectOutputStream类保存基本类型数据或对象的机制

  • 反序列化：用ObjectInputStream类读取基本类型数据或对象的机制

  • ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

对象的序列化

  • **对象序列化机制**允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传 输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象

  • 序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据， 使其在保存和传输时可被还原

  • 序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返 回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是 JavaEE 平台的基础

  • 如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。 否则，会抛出NotSerializableException异常

    • Serializable
    • Externalizable

  • 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：

    • private static final long serialVersionUID;—序列版本号
    • serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
    • 如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议，显式声明。

  • 简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的 serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)

  • 若某个类实现了 Serializable 接口，该类的对象就是可序列化的：

    • 创建一个 ObjectOutputStream
    • 调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象
    • 注意写出一次，操作flush()一次

  • 反序列化

    • 创建一个 ObjectInputStream
    • 调用readObject() 方法读取流中的对象

强调：如果某个类的属性不是基本数据类型或 String 类型，而是另一个 引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的 Field 的类也不能序列化

上一篇：外边距（margin）重叠问题


下一篇：小师妹学JavaIO之:MappedByteBuffer多大的文件我都装得下