一、Java知识图解

image.png

二、File类的使用

1、File类概述

  • java.io.file类：文件和文件目录路径的抽象表示形式，与平台无关
  • File 能新建、删除、重命名文件和目录，但File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流
  • 想要在java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

  • File 对象可以作为参数传递给流的构造器

    2、File类使用：常用构造器

  • public File(String pathname)

以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性uset.dir中存储。
|- 绝对路径：是一个固定的路径，从盘符开始
|- 相对路径：是相对于某个位置开始

  • public File(String parent, String child)

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

  • public File(File parent, String child)

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

3、File使用：路径分隔符

  • 路径中的每级目录之间用一个路径分隔符隔开
  • 路径分隔符和系统有关

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

  • java程序支持跨平台运行，因此路径分隔符要慎用
  • 问了解决这个隐患，File类提供了一个常量
    • public static final String separator 根据操作系统，动态的提供分隔符
    • 举例：

image.png

4、File类的使用：常用方法

  • 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类的重命名功能

|- public boolean renameTo(File dest)：把文件重命名为指定的文件路径

  • File类的判断功能

|- public boolean isDirectory()：判断是否是文件目录
|- public boolean isFile()：判断是否是文件
|- public boolean exists()：判断是否存在
|- public boolean canRead()：判断是否可读
|- public boolean canWrite()：判断是否可写
|- public boolean isHiddent()：判断是否隐藏

  • File类的创建

|- public boolean createNewFile()：创建文件。若文件存在，则不创建，返回false
|- public boolean mkdir()：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建了
|- public boolean mkdirs()：创建文件目录。如果上层文件目录不存在，一并创建
注意：如果在创建文件或者文件目录没有写盘符路径，那么，默认在项目路径下

  • File类的删除功能

|- public boolean delete()：删除文件或文件夹
删除注意事项：
java中的删除不走回收站。
要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录

  1.  public void testFile() throws IOException {
  2.         File file1 = new File("D:" + File.separator + "dir1");
  3.         if (!file1.exists()){
  4.             file1.mkdir();
  5.             System.out.println("目录：" + file1.getName() + "，路径：" + file1.getPath() + "，绝对路径：" + file1.getAbsolutePath() + "已经创建！");
  6.         }
  7.         File file2 = new File(file1,File.separator + "dir2" + File.separator + "dir3");
  8.         if (!file2.exists()){
  9.             file2.mkdirs();
  10.             System.out.println("目录：" + file2.getName() + "，路径：" + file2.getPath() + "，绝对路径：" + file2.getAbsolutePath() + "已经创建！");
  11.         }
  12.         File file3 = new File(file2,"dir4");
  13.         if (!file3.exists()){
  14.             file3.mkdirs();
  15.             System.out.println("目录：" + file3.getName() + "，路径：" + file3.getPath() + "，绝对路径：" + file3.getAbsolutePath() + "已经创建！");
  16.         }
  17.         File file7 = new File("D:" + File.separator + "dir1" + File.separator + "dir2");
  18.         if (file7.delete()){
  19.             System.out.println("文件：" + file7.getName() + "，路径：" + file7.getPath() + "，绝对路径：" + file7.getAbsolutePath() + "已经删除成功！");
  20.         } else {
  21.             System.out.println("文件：" + file7.getName() + "，下存在其它文件夹或文件，此文件夹不允许删除！");
  22.         }
  24.         // 获取指定目录下后缀为.jpg的文件，并输出文件名
  25.         String[] list = file3.list();
  26.         for (int i = 0; i < list.length; i++){
  27.             String fileName = list[i];
  28.             if (fileName.lastIndexOf(".jpg") > -1){
  29.                 System.out.println(list[i]);
  30.             }
  31.         }
  33.         // 计算指定目录占用空间的大小
  34.         File[] fileList = file3.listFiles();
  35.         long count = 0L;
  36.         for (int j = 0; j < fileList.length; j++){
  37.             File file = fileList[j];
  38.             count += file.length();
  39.         }
  40.         System.out.println(count);
  42.         // 删除指定文件目录及其下的所有文件
  43.         deleteDir(file7);
  44.         if (!file7.exists()){
  45.             System.out.println("文件：" + file7.getName() + "，路径：" + file7.getPath() + "，绝对路径：" + file7.getAbsolutePath() + "已经删除成功！");
  46.         } else {
  47.             System.out.println("文件：" + file7.getName() + "，下存在其它文件夹或文件，此文件夹不允许删除！");
  48.         }
  49.     }
  51.     // 递归删除存在文件或文件夹的目录
  52.     private static boolean deleteDir(File dir) {
  53.         if (dir.isDirectory()) {
  54.             String[] children = dir.list();
  55.             //递归删除目录中的子目录下
  56.             for (int i=0; i<children.length; i++) {
  57.                 boolean success = deleteDir(new File(dir, children[i]));
  58.                 if (!success) {
  59.                     return false;
  60.                 }
  61.             }
  62.         }
  63.         // 目录此时为空，可以删除
  64.         return dir.delete();
  65.     }
  68.     @Test
  69.     public void copyFile() throws IOException {
  70.         File file1 = new File("D:" + File.separator + "test" + File.separator+"startCopyFile");
  71.         if (!file1.exists()){
  72.             file1.mkdirs();
  73.         }
  74.         File file2 = new File("D:" + File.separator + "test" + File.separator+"endCopyFile");
  75.         if (!file2.exists()){
  76.             file2.mkdirs();
  77.         }
  78.         File file3 = new File(file1, "hello.txt");
  79.         File file4 = new File(file2, "helloHistory.txt");
  80.         // 文件复制
  81.         System.out.println(Files.copy(file3.toPath(),file4.toPath()));
  82.         // 文件移动
  83. //        System.out.println(file1.renameTo(file2));
  84.     }

三、IO流原理及流的分类

1、Java IO原理

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

  • 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备之中

    2、流的分类

  • 按操作数据单位不同分为：字节流（8bit），字符流（16bit）

  • 按数据流的流向不同分为：输入流，输出流
  • 按流的角色的不同分为：节点流，处理流

image.png
（1）java的IO流共设计40多个类，实际上非常规则，都是从如上4个抽象基类派生出的。
（2）由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。
image.png
image.png

3、I/O流体系

image.png

4、节点流和处理流

  • 节点流：直接从数据源或目的地读写数据

image.png

  • 处理流：不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或数据流）之上，通过对数据的处理为程序提供更强大的读写功能

image.png

5、InputStream & Reader

  • InputStream和Reader是所有输入流的基类
  • InputStream（典型实现：FileInputStream）

|- int read()
|- int read(byte[] b)
|- int read(byte b, int off, int len)

  • 程序中打开的文件IO资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显示关闭文件IO资源

  • FileInputStream从文件系统中的某个文件中获得输入字节。FileInputStream用于读取非文本数据之类的原始字节流。要读取字符流，需要使用FileReader

    6、InputStream

  • int read()

从输入流中读取数据的下一个字节。返回0到255范围内的int字节值。如果因为已经到达流末尾而没有可用的字节，则返回值-1。

  • int read(byte[] b)

从此输入流中将最多b.length个字节的数据读入一个byte数组中。如果因为已经到达末尾而没有可用的字节，则返回-1。否则以整数形式返回实际读取的字节数。

  • int read(byte[] b, int off, int len)

将输入流中最多len个字节读入到byte数组。尝试读取len个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值-1。

  • public void close() throws IOException

关闭此输入流并释放与流关联的所有系统资源

7、Reader

  • int read()

读取单个字节。作为整数读取的字符，范围在0到65535之间，如果已经到达流的末尾，则返回-1

  • int read(char[] cbuf)

将字符读入数组。如果已到达流的末尾，则返回-1.否则返回本次读取的字符数

  • int read(char[] cbuf, int off, int len)

将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，至于多读len个字符。如果已到达流的末尾，则返回-1。否则返回本次读取的字符数。

  • public void close() throws IOException

关闭此输入流并释放与该流关联的所有系统资源

8、OutputStream & Writer

  • OutputStream和Writer也非常相似

|- void write(int b/int c);
|- void write(byte[] b/char[] cbuf);
|- void write(byte[]/char[] buff, int off, int len);
|- void fiush();
|- void close(); 需要先刷新，再关闭此流

  • 因为字符流直接以字符作为操作单位，所以Writer可用用字符串来替换字符数组，即以String对象作为参数

|- void write(String str);
|- void write(String str, int off, int len);

  • FileOutputStream从文件系统中的某个文件中获得输出字节。FileOutputStream用于写出非文本数据之类的原始字节流。要写出字符流，需要FileWriter

    9、OutputStream

  • void write(int b)

将指定的字节写入此输出流。write的常规协定是：向输出流写入一个字节。要写入的字节是参数b的八个低位，b的24个高位将被忽略。即写入0~255范围的。

  • void write(byte[] b)

将b.length个字节从指定的byte数组写入此输出流。write(b)的常规协定是：应该与调用write（b, 0, length）的效果完全相同。

  • void write(byte[] b, int off, int len)

将指定byte数组中从偏移量off开始的len个字节写入此输出流。

  • public void flush() throws IOException

刷新此输出流，并强制写出所有缓冲输出字节，调用此方法指示应将这些字节写入它们预期的目标

  • public void close() throws IOException

关闭此输出流并释放与该流关联的所有系统资源。

10、Writer

  • void write(int c)

写入单个字符。要写入的字符包含在给定整数值的16个低位中，16高位被忽略。即写入0到65535之间的Unicode码。

  • void write(char[] cbuf)

写入字符数组。

  • void write(char[] cbuf,int off,int len)

写入字符数组的某一部分。从off开始，写入len个字符

  • void write(String str)

写入字符串。

  • void write(String str,int off, int len)

写入字符串的某一部分。

  • void flush()

刷新该流的缓冲，则立即将它们写入预期目标。

  • public void close() throws lOException

关闭此输出流并释放与该流关联的所有系统资源。

四、节点流

1、读取文件

image.png
image.png

2、写入文件

image.png
image.png

  1. public void testFileReader() throws IOException {
  2.         File file = new File("D:\\dir1\\testNote.txt");
  3.         if (!file.exists()){
  4.             file.createNewFile();
  5.         }
  6.         FileWriter fileWriter = new FileWriter(file);
  7.         fileWriter.write("hello mojh");
  8.         fileWriter.flush();
  9.         if (fileWriter != null){
  10.             fileWriter.close();
  11.         }
  12.         FileReader fileReader = new FileReader(file);
  13.         char [] cbuf = new char [1024];
  14.         fileReader.read(cbuf);
  15.         System.out.println(cbuf);
  16.         fileReader.close();
  17.     }
  • 定义文件路径时，注意：可以用“/”或者“\”。
  • 再写入一个文件时，如果使用构造器FileOutputStream(file)，则目录下有同名文件将被覆盖。
  • 如果使用构造器FileOuputStream(flie,true),则目录下的同名文件不会被覆盖，在文件内容末尾追加内容。
  • 在读取文件时，必须保证该文件已存在，否则报异常
  • 字节流操作字节，比如：.mp3，.avi，.rmvb，.mp4，.jpg，ppt

  • 字符流操作字符，只能操作普通文本文件。最为常见的文本文件：.txt，.java，.c，.app等语言的源代码。尤其注意：.doc,excel.ppt这些不是文本文件。

    五、处理流之一：缓冲流

    1、缓冲流概述

  • 为了提高数据读写速度，java API提供了带缓存功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节（8kb）的缓冲区。

image.png

  • 缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓存流分为：

|- BufferedInputStream 和 BufferedOutputStream
|- BufferedReader 和 BufferedWriter

  • 当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区
  • 当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个字节（8kb），存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组。
  • 向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。使用方法flush()可以强制将缓冲区的内容全部写入输出流。
  • 关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流
  • flush()方法的使用：手动将buffer中内容写入文件
  • 如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出

image.png

2、缓存流常用方法

  • BufferedReader 字符输出缓冲流

    • 构造方法 Constructor：

      BufferedReader(Reader in);

    • 常用方法 Method:

      |- int read();
      |- int read(byte[] buf);
      |- String readLine(); 【新方法】
      从文件中读取一行数据，返回值类型是字符串，如果读取到文件默认，返回null

  • BufferedWriter 字符输出缓冲流

    • 构造方法 Constructor:

      BufferedWriter(Writer in);

    • 常用方法:

      void write(int ch);
      void write(char[] buf);
      void write(char[] buf, int off, int len);
      void write(String str);
      void write(String str, int off, int len);
      void newLine(); 换行操作

      1. public void testBufferStream() throws IOException {
      2.    BufferedWriter bw = null;
      3.    BufferedReader br = null;
      4.    File file = new File("D:\\dir1\\testNote.txt");
      5.    bw = new BufferedWriter(new FileWriter(file,true)); //若需要在文件的末尾追加元素，则在节点流位置构造时，添加true（默认为false）
      6.    String insert = "hello Jhon";
      7.    try {
      8.        bw.write(insert);
      9.        bw.newLine();
      10.        bw.flush();
      11.    } catch (IOException e) {
      12.        e.printStackTrace();
      13.    } finally {
      14.        if (bw != null){
      15.            bw.close();
      16.        }
      17.    }
      19.    br = new BufferedReader(new FileReader(file));
      20.    String line = null;
      21.    StringBuffer stringBuffer = new StringBuffer();
      22.    while((line = br.readLine()) != null){
      23.        stringBuffer.append(line).append("\n");
      24.    }
      25.    System.out.println(stringBuffer);
      26. }
  1. import java.io.*;
  2. import java.util.Scanner;
  4. /**
  5.  * @Auther: mojh
  6.  * @Date: 2022/05/26/10:52
  7.  * @Description:
  8.  */
  9. public class WriterToFile {
  11.     public static void main(String[] args) throws Exception {
  12.         // 控制台输入
  13.         Scanner scanner = new Scanner(System.in);
  14.         // 需要处理的文件
  15.         File file = new File("D:" + File.separator + "test" + File.separator + "startCopyFile" + File.separator + "hello.txt");
  16.         while (scanner.hasNext()){
  17.             String str = scanner.next();
  18.             if ("exit".equals(str)){
  19.                 break;
  20.             }
  21.             // 取出数据写到文件 start
  22.             BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file,true));
  23.             try {
  24.                 bufferedWriter.write(str);
  25.                 bufferedWriter.newLine();
  26.                 bufferedWriter.flush();
  27.                 System.out.println("成功写入文件：" + str);
  28.             } catch (Exception e){
  29.                 e.printStackTrace();
  30.             } finally {
  31.                 if (bufferedWriter != null){
  32.                     bufferedWriter.close();
  33.                 }
  34.             }
  35.         }
  36.         // 读取当前文件的内容
  37.         BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
  38.         StringBuilder sb = new StringBuilder();
  39.         while (true){
  40.             String result = bufferedReader.readLine();
  41.             if (result == null){
  42.                 break;
  43.             }
  44.             sb = sb.append(result).append("\n");
  45.         }
  46.         String content = sb.toString();
  47.         System.out.println(content);
  48.     }
  49. }

六、处理流之二：转换流

1、转换流概述

  • 转换流提供了在字节流和字符流之间的转换
  • java Api提供了两个转换流：

|- InputStreamReader：将InputStream转换为Reader
|- OutputStreamWriter：将Writer转换为OutputStream

  • 字节流中的数据都是字符时，转换成字符流操作更高效
  • 很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能

（个人理解：转换流的作用主要是为了指定把字符的输入或输出按某种格式进行。）
（个人理解：缓冲流的作用主要是为了加速数据的传输，提高效率，按块传输 8kb）

2、InputStreamReader

  • 实现将字节的输入流按指定字符集转换为字符的输入流
  • 需要和InputStream“套接”
  • 构造器

|- public InputStreamReader(InputStream in)
|- public InputStreamReader(InputStream in, String charseName)
如：Reader isr = new InputStreamReader(System.in, “utf-8”)

3、OutputStreamReader

  • 实现将字节的输入流按指定字符集转换为字符的输出流
  • 需要和OutputStream“套接”
  • 构造器

|- public OutputStreamReader(InputStream in)
|- public OutputStreamReader(InputStream in, String charseName)
如：Writer isw = new OutputStreamReader(System.out, “utf-8”)
image.png
image.png

七、标准流(了解)

  • System.in和System.out分别代表了系统标准的输入和输出设备
  • 默认输入设备是：键盘，输出设备是：显示器
  • System.in的类型是InputStream
  • System.out的类型是PrintStream，其是OutputStream的子类FileOutputStream的子类

  • 重定向：通过System类的setIn，setOut方法对默认设备进行改变。

    • public static void setIn(inoutStream in)
    • public static void setOut(PrintStream out)
      1. public static void main(String[] args) throws IOException {
      2.    System.out.println("小写转大写，按“e”或“eixt退出");
      3.    InputStream in = System.in;
      4.    InputStreamReader inputStreamReader = new InputStreamReader(in,"utf-8");
      5.    BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
      6.    String line = null;
      7.    while ((line = bufferedReader.readLine()) != null){
      8.        if ("e".equalsIgnoreCase(line) || "exit".equalsIgnoreCase(line)){
      9.            System.out.println("安全退出！");
      10.            break;
      11.        }
      12.        System.out.println(line.toUpperCase());
      13.    }
      14.    bufferedReader.close();
      15. }

      八、处理流之四：打印流（了解）

  • 实现将基本数据类型的数据格式转化为字符串输出

  • 打印流：PrintStream和PrintWriter

|- 提供了一系列重载的print()和printin()方法，用于多种数据类型的输出
|- PrintStream和PrintWriter的输出不会抛出IOException异常
|- PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类。
|- System.out返回的是PrintStream的实例

九、处理流之五：数据流（了解）

  • 为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。
  • 数据流有两个类：（用于读取和写出基本数据类型、String类的数据）

|- DataInputStream 和 DataOutputStream
|- 分别“套接”在InputStream 和 OutputStream 子类的流上

  • DataInputStream中的方法：

image.png

  • DataOutputStream中的方法

|- 将上述的方法的read改为相应的write即可。
image.png
image.png

十、处理流之六：对象流

1、对象流概述

  • ObjectInputStream和ObjectOutputStream

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

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

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

    2、对象的序列化

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

  • 序列化的好处在于将实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
  • 序列化是RMI（Remote Method Invoke - 远程方法调用）过程的参数和返回值都必须实现的机制，而RMI是JavaEE的基础。因此序列化机制是JavaEE平台的基础
  • 如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。

|- Serializable
|- Externalizable

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

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

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

    3、使用对象流序列化对象

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

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

  • 反序列化

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

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

image.png

  1. // 序列化与反序列化
  2.     @Test
  3.     public void testSerializable() throws IOException, ClassNotFoundException {
  5.         File file = new File("D:" + File.separator  + "dir1" + File.separator + "Student.txt");
  6.         if (!file.exists()){
  7.             file.createNewFile();
  8.         }
  10.         Student student = new Student(4,"man","Layou",18);
  11.         ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(file));
  12.         objectOutputStream.writeObject(student);
  13.         objectOutputStream.flush();
  14.         objectOutputStream.close();
  16.         ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
  17.         Student o = (Student) objectInputStream.readObject();
  18.         System.out.println(o);
  19.         objectInputStream.close();
  20.     }
  1. //Student类要实现接口Serializable
  2. import java.io.Serializable;
  3. import java.util.Objects;
  5. /**
  6.  * @Auther: mojh
  7.  * @Date: 2021/09/01/15:10
  8.  * @Description:
  9.  */
  10. public class Student implements Serializable {
  12.     private static final long serialVersionUID = 123123123L;
  14.     private Integer id;
  15.     private String sex;
  16.     private String name;
  17.     private Integer age;
  19.     public Student() {
  20.     }
  22.     public Student(Integer id, String sex, String name, Integer age) {
  23.         this.id = id;
  24.         this.sex = sex;
  25.         this.name = name;
  26.         this.age = age;
  27.     }
  29.     @Override
  30.     public boolean equals(Object o) {
  31.         if (this == o) return true;
  32.         if (o == null || getClass() != o.getClass()) return false;
  33.         Student student = (Student) o;
  34.         return Objects.equals(id, student.id) &&
  35.                 Objects.equals(sex, student.sex) &&
  36.                 Objects.equals(name, student.name) &&
  37.                 Objects.equals(age, student.age);
  38.     }
  40.     @Override
  41.     public int hashCode() {
  43.         return Objects.hash(id, sex, name, age);
  44.     }
  46.     @Override
  47.     public String toString() {
  48.         return "Student{" +
  49.                 "id=" + id +
  50.                 ", sex='" + sex + '\'' +
  51.                 ", name='" + name + '\'' +
  52.                 ", age='" + age + '\'' +
  53.                 '}';
  54.     }
  56.     public Integer getId() {
  57.         return id;
  58.     }
  60.     public void setId(Integer id) {
  61.         this.id = id;
  62.     }
  64.     public String getSex() {
  65.         return sex;
  66.     }
  68.     public void setSex(String sex) {
  69.         this.sex = sex;
  70.     }
  72.     public String getName() {
  73.         return name;
  74.     }
  76.     public void setName(String name) {
  77.         this.name = name;
  78.     }
  80.     public Integer getAge() {
  81.         return age;
  82.     }
  84.     public void setAge(Integer age) {
  85.         this.age = age;
  86.     }
  87. }

4、Serializable接口面试题

image.png

十一、随机存储文件流

image.png
image.png
image.png

  • 扩展：断点续传和下载原理：https://www.cnblogs.com/wangzehuaw/p/5610851.html

    十二：流总结

    1、流是用来处理数据的
    2、处理数据时，一定要先明确数据源，与数据目的地
    |- 数据源可以是文件、可以是键盘
    |- 数据目的地可以是文件、显示器、或者其它设备
    3、而流只是在帮助数据进行传输，并对传输的数据进行处理，比如过滤处理、转换处理等。