• 深入理解Java IO流（第三篇）

    ✅作者简介：大家好我是@每天都要敲代码，一位材料转码农的选手，希望一起努力，一起进步！
    📃个人主页：@每天都要敲代码的个人主页

    🔥系列专栏：JavaSE从入门到精通
    💬推荐一款模拟面试、刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习

    目录

    🥅目录拷贝

    🥅ObjectInputStream && ObjectOutputStream

    1.序列化的实现

    2.反序列化的实现

    3.序列化 && 反序列化多个对象

    4.序列化版本号

    🥅IO和Properties联合使用

    结束语

    🥅目录拷贝

    把一个目录拷贝到另一个目录
    需要用到：FileInputStream+FileOutputStream+File+递归的思想

    1. package com.bjpowernode.java.io;
    2.  
    3. import java.io.*;
    4.  
    5. public class CopyAll {
    6.     public static void main(String[] args) {
    7.         // 拷贝源
    8.         File srcFile = new File("C:\\Java学习\\javaSE学习");
    9.         // 拷贝目标
    10.         File destFile = new File("D:\\a\\b\\c");
    11.         // 调用方法进行拷贝
    12.         copyDir(srcFile,destFile);
    13.     }
    14.  
    15.     /**
    16.      * 拷贝目录
    17.      * @param srcFile 拷贝源
    18.      * @param destFile 拷贝目标
    19.      */
    20.     private static void copyDir(File srcFile, File destFile) {
    21.         //4、递归结束的条件，如果是文件就结束（就开始拷贝）
    22.         if(srcFile.isFile()){
    23.             // 是文件的是要要拷贝文件，一边读一遍写
    24.             FileInputStream in = null;
    25.             FileOutputStream out = null;
    26.             try {
    27.                 // 读文件
    28.                 in = new FileInputStream(srcFile);
    29.                 // 写文件
    30.                 String path =  (destFile.getAbsolutePath().endsWith("\\")?destFile.getAbsolutePath() :
    31.                         destFile.getAbsolutePath()+"\\")+srcFile.getAbsolutePath().substring(3);
    32.                 System.out.println(path);
    33.                out = new FileOutputStream(path);
    34.                 // 一边读一边写
    35.                 byte[] bytes = new byte[1024*1024];// 1M
    36.                 int readCount = 0;
    37.                 while((readCount = in.read(bytes)) != -1){
    38.                     out.write(bytes,0,readCount);
    39.                 }
    40.                 // 刷新
    41.                 out.flush();
    42.             } catch (FileNotFoundException e) {
    43.                 e.printStackTrace();
    44.             } catch (IOException e) {
    45.                 e.printStackTrace();
    46.             } finally {
    47.                 if (out != null) {
    48.                     try {
    49.                         out.close();
    50.                     } catch (IOException e) {
    51.                         e.printStackTrace();
    52.                     }
    53.                 }
    54.                 if (in != null) {
    55.                     try {
    56.                         in.close();
    57.                     } catch (IOException e) {
    58.                         e.printStackTrace();
    59.                     }
    60.                 }
    61.             }
    62.             return; // srcFile如果是一个文件，递归结束
    63.         }
    64.  
    65.         //1、 获取拷贝源下面的子目录
    66.         File[] files = srcFile.listFiles(); //列出源文件下的子目录（目录和文件）
    67.         // 这个file有可能是目录，也有可能是文件；但都是一个File对象
    68.         for(File file:files){
    69.             // 获取所有文件的（目录和文件）绝对路径；进行打印测试
    70.             //System.out.println(file.getAbsolutePath());
    71.  
    72.             // 3、创建对应的目录（目标文件对应的目录，要提前创建好）
    73.             if(srcFile.isDirectory()){ // 如果是一个目录
    74.                 // 新建对应的目录
    75.                 String srcDir = file.getAbsolutePath(); // 拿出所有的源目录
    76.                 // 这里如果只是一个盘符的话，写上"//"会被识别出来；如果后面有其它目录，就识别不了"//"
    77.                 // srcDir.substring(3)表示从下标为3的地方开始截取
    78.                 String destDir = (destFile.getAbsolutePath().endsWith("\\")? destFile.getAbsolutePath() :
    79.                         destFile.getAbsolutePath()+"\\")+srcDir.substring(3); // 目标目录
    80.                 // 获取路径后，开始创建
    81.                 File newFile = new File(destDir);
    82.                 if(!newFile.exists()){ // 如果不存在，就递归创建目录
    83.                     newFile.mkdirs();
    84.                 }
    85.             }
    86.  
    87.             //2、 递归调用（是目录的话一直往下拿，直到是一个文件就开始拷贝）
    88.             copyDir(file,destFile);
    89.  
    90.         }
    91.     }
    92. }

    🥅ObjectInputStream && ObjectOutputStream

    1、首先我们先明白两个概念：序列化（Serialize）和反序列化（DeSerialize）

            序列化：将java对象存储到文件中，将java对象的状态保存下来的过程

            反序列化：将硬盘上的数据重新恢复到内存当中，恢复成java对象

    2、ObjectInputStream 和 ObjectOutputStream的作用

            ObjectOutputStream是用来序列化的---》拆分对象

            ObjectInputStream是用来反序列化的---》组装对象

    3、通过图，来理清楚它们之间的关系

     

    1.序列化的实现

    （1）参与序列化和反序列化的对象，必须实现Serializable接口。如果下面的Student类没有实现Serializable接口，会报java.io.NotSerializableException，译为：Student对象不支持序列化！

    （2）注意：通过源代码发现，Serializable接口只是一个标志接口：

    1.  public interface Serializable {
    2.     }

    （3）这个接口当中什么代码都没有；那么它起到一个什么作用呢？
           起到标识的作用，标志的作用，java虚拟机看到这个类实现了这个接口，可能会对这个类进行特殊待遇。Serializable这个标志接口是给java虚拟机参考的，java虚拟机看到Serializable这个接口之后，会为该类自动生成一个序列化版本号。

    1. package com.bjpowernode.java.io;
    2.  
    3. import java.io.FileOutputStream;
    4. import java.io.ObjectOutputStream;
    5. import java.io.Serializable;
    6.  
    7.  
    8. public class ObjectOutputStreamTest01 {
    9.     public static void main(String[] args) throws Exception {
    10.         // 创建Java对象
    11.         Student stu = new Student(111,"zhangsan");
    12.         // 序列化
    13.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("s文件"));
    14.         // 序列化对象
    15.         oos.writeObject(stu);
    16.         // 刷新
    17.         oos.flush();
    18.         // 关闭
    19.         oos.close();
    20.  
    21.  
    22.     }
    23. }
    24.  
    25. // 学生类
    26. class Student implements Serializable {
    27.     private int no;
    28.     private String name;
    29.     // 构造方法
    30.     public Student() {
    31.     }
    32.     public Student(int no, String name) {
    33.         this.no = no;
    34.         this.name = name;
    35.     }
    36.     // setter and getter
    37.     public int getNo() {
    38.         return no;
    39.     }
    40.     public void setNo(int no) {
    41.         this.no = no;
    42.     }
    43.     public String getName() {
    44.         return name;
    45.     }
    46.     public void setName(String name) {
    47.         this.name = name;
    48.     }
    49.     // 重写toString
    50.     public String toString() {
    51.         return "Student{" +
    52.                 "no=" + no +
    53.                 ", name='" + name + '\'' +
    54.                 '}';
    55.     }
    56. }

    2.反序列化的实现

    1. package com.bjpowernode.java.io;
    2. // 反序列化
    3. import java.io.FileInputStream;
    4. import java.io.ObjectInputStream;
    5.  
    6. public class ObjectInputStreamTest01 {
    7.     public static void main(String[] args) throws Exception{
    8.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("s文件"));
    9.         // 开始反序列化，读
    10.         Object obj = ois.readObject();
    11.         // 反序列化回来是一个学生对象，所以会调用学生对象的toString方法。
    12.         System.out.println(obj);
    13.         // 关闭
    14.         ois.close();
    15.     }
    16. }

    3.序列化 && 反序列化多个对象

    1、可以一次序列化多个对象呢？
         可以将对象放到集合当中，序列化集合！
    2、参与序列化的ArrayList集合以及集合中的元素User都需要实现 java.io.Serializable接口。

    3、补充一个关键字：transient；这个关键字表示游离的，不参与序列化。     

    序列化 

    1. package com.bjpowernode.java.io;
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.ObjectOutputStream;
    6. import java.io.Serializable;
    7. import java.util.ArrayList;
    8. import java.util.List;
    9.  
    10. public class ObjectOutputStreamTest02 {
    11.     public static void main(String[] args) throws Exception {
    12.         // 创建集合
    13.         List userList = new ArrayList<>();
    14.         // 增加元素
    15.         userList.add(new User(1,"zhangsan"));
    16.         userList.add(new User(2,"lisi"));
    17.         userList.add(new User(3,"wangwu"));
    18.         // 序列化
    19.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Users"));
    20.         // 序列化集合--->一次性序列化多个对象
    21.         oos.writeObject(userList);
    22.  
    23.         // 刷新
    24.         oos.flush();
    25.         // 关闭
    26.         oos.close();
    27.  
    28.  
    29.     }
    30. }
    31.  
    32. // USer类
    33. class User implements Serializable {
    34.     private int num;
    35.     private transient String name; // name不参与序列化操作;name打印出来的结果就是null
    36.     // 构造方法
    37.     public User() {
    38.     }
    39.     public User(int num, String name) {
    40.         this.num = num;
    41.         this.name = name;
    42.     }
    43.     // setter and getter
    44.     public int getNum() {
    45.         return num;
    46.     }
    47.     public void setNum(int num) {
    48.         this.num = num;
    49.     }
    50.     public String getName() {
    51.         return name;
    52.     }
    53.     public void setName(String name) {
    54.         this.name = name;
    55.     }
    56.     // 重写toStringF方法
    57.     public String toString() {
    58.         return "User{" +
    59.                 "num=" + num +
    60.                 ", name='" + name + '\'' +
    61.                 '}';
    62.     }
    63. }

    反序列化 

    1. package com.bjpowernode.java.io;
    2.  
    3. import java.util.List;
    4. import java.io.FileInputStream;
    5. import java.io.ObjectInputStream;
    6.  
    7. // 反序列化
    8. public class ObjectInputStreamTest02 {
    9.     public static void main(String[] args) throws Exception {
    10.         // 开始反序列化，读
    11.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Users"));
    12.         // 反序列化回来一个List集合
    13.         //Object obj = ois.readObject();
    14.         //System.out.println(obj instanceof List); // true,得到返回的是List集合
    15.  
    16.        List userList = (List)ois.readObject();
    17.        for(User u:userList){
    18.            System.out.println(u);
    19.        }
    20.         // 关闭
    21.         ois.close();
    22.     }
    23. }

    4.序列化版本号

    （1）java语言中是采用什么机制来区分类的？
          第一：首先通过类名进行比对，如果类名不一样，肯定不是同一个类。
          第二：如果类名一样，再怎么进行类的区别？靠序列化版本号进行区分。

    （2）序列化版本号有什么用呢？

        小鹏编写了一个类：com.bjpowernode.java.bean.Student implements Serializable
        胡浪编写了一个类：com.bjpowernode.java.bean.Student implements Serializable

    所以序列化版本号是用来区分类的！例如：类名相同，我们可以通过不通的序列化版本号来区分它；对于但也有缺点，对于同一个代码，我们更改了，必须重新编译才可以！

    例如：对于上述的Student类，我们采用默认的序列化版本号，一年前我们实现了这个功能，有一个序列化版本号；一年后我们优化更改了代码，此时JVM就会认为这已经不是同一个类，必须重新进行编译，才能反序列化
    （3）自动生成序列化版本号的好处和缺陷    

    好处：不同的人编写了同一个类，但“这两个类确实不是同一个类”。这个时候序列化版本就起上作用了。对于java虚拟机来说，java虚拟机是可以区分开这两个类的，因为这两个类都实现了Serializable接口，都有默认的序列化版本号，他们的序列化版本号不一样。所以区分开了。）
    缺陷：这种自动生成的序列化版本号缺点是一旦代码确定之后，不能进行后续的修改，因为只要修改，必然会重新编译，此时会生成全新的序列化版本号，这个时候java虚拟机会认为这是一个全新的类。

    （4）总结：从需求来看

    凡是一个类实现了Serializable接口，建议给该类提供一个固定不变的序列化版本号。这样，以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类。

    Java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号。
    这里没有手动写出来，java虚拟机会默认提供这个序列化版本号。
    建议将序列化版本号手动的写出来。不建议自动生成
       

     private static final long serialVersionUID = 1L;

       java虚拟机识别一个类的时候先通过类名，如果类名一致，再通过序列化版本号。

    （5）设置IDEA自动生成序列版本号

    File--->Settings--->Code Style--->Inspections--->把下面这个打上对勾--->Apply--->OK

     

     最终回到我们继承Serializable接口的类名上，alt+Enter即可自动生成序列版本号

    🥅IO和Properties联合使用

    （1）设计理念：把以后经常改变的数据，可以单独写到一个文件中，使用程序动态读取。
        将来只需要修改这个文件的内容，java代码不需要改动，不需要重新编译，服务器也不需要重启；就可以拿到动态的信息。

    （2）类似于以上机制的这种文件被称为配置文件；并且当配置文件中的内容格式是：
            key1=value
            key2=value
    的时候，我们把这种配置文件叫做属性配置文件，在属性配置文件当中#注释，如果key重复的话，value会自动覆盖。

    （3）java规范中有要求：属性配置文件建议以.properties结尾，但这不是必须的。
        这种以.properties结尾的文件在java中被称为：属性配置文件；其中Properties是专门存放属性配置文件内容的一个类

    （4）Properties是一个Map集合，key和value都是String类型。

    1. package com.bjpowernode.java.io;
    2.  
    3. import java.io.FileReader;
    4. import java.util.Properties;
    5.  
    6. public class IoProperiesTest02 {
    7.     public static void main(String[] args) throws Exception {
    8.         // 新建一个输入流对象
    9.         FileReader reader = new FileReader("temp.txt");
    10.         // 新建一个Map集合
    11.         Properties pro = new Properties();
    12.         // 调用Properties对象的load方法将文件中的数据加载到Map集合中。
    13.         pro.load(reader);// 文件中的数据顺着管道加载到Map集合中，其中等号=左边做key，右边做value
    14.         // 通过key获取value
    15.         String username = pro.getProperty("username");
    16.         System.out.println(username); //admin
    17.         // 如果我们把admin改成root，不需要重新进行编译，就能直接运行得到root
    18.         System.out.println(pro.getProperty("password")); // 123
    19.     }
    20.  
    21. }
    22.  
    23. /*temp.txt文件里的内容
    24. username=admin
    25. password=123
    26.         */

    结束语

    今天的分享就到这里啦！快快通过下方链接注册加入刷题大军吧！各种大厂面试真题在等你哦！

     💬刷题神器，从基础到大厂面试题👉点击跳转刷题网站

  • 相关阅读:
    terraform简单的开始-vpc cvm创建
    数据集成面试题
    Hive新增/变更字段后，Hive metastore与Hive tblproperties缓存的spark schema不一致处理
    MongoDB 简介
    由浅入深——晶体管放大电路基础
    刷题记录:牛客NC51170石子合并
    Javascript知识【jQuery-基本操作】下篇
    华为略施小计，问界M7销量暴增10倍？
    Impeller-Flutter的新渲染引擎
    Rust中的输入输出格式变化（非常详细）
  • 原文地址：https://blog.csdn.net/m0_61933976/article/details/126151346