Java文件操作和IO📍内容导读📍 Java文件操作和IO 🍎 一：文件及文件操作 🍓1.文件流： 🍓2.创建

📍内容导读📍 Java文件操作和IO 🍎 一：文件及文件操作 🍓1.文件流： 🍓2.创建文件： 🍓3.获取文件信息 🍓4.目录操作 🍎 二：IO流原理及分类 🍓1.简述原理 🍓2.流的分类 🍓3.FileInputStream 🍓4.FileOutputStream 🍓5.作业总结1 🍓6.文件拷贝 🍓7.文件字符流（FileReader、FileWriter） 🍓8.节点流和处理流处理流解析： 1.字符处理流 2.字节处理流 3.对象处理流 4.标准输入输出流 5.转换流 6.打印流 8.Properties类 🍓9.作业总结2 Java文件操作和IO 🍎 一：文件及文件操作 🍓1.文件流：文件在程序中以流的形式来操作

数据从数据源（文件）到程序之间的路径为输入流，从程序到数据源（文件）之间的路径为输出流

🍓2.创建文件： new File(String pathname)//路径构建

public void create01() {
    String pathname="d:\\news1.txt";
    File file = new File(pathname);
    try {
        file.createNewFile();
        System.out.println("创建成功");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

1 2 3 4 5 6 7 8 9 10 new File(File parent,String child)//父目录文件+子路径

public void create02() { File parentFile = new File("d:\"); String fileName="news2.txt"; File file=new File(parentFile,fileName); try { file.createNewFile(); System.out.println("创建成功02"); } catch (IOException e) { e.printStackTrace(); } 1 2 3 4 5 6 7 8 9 10 new File(String parent,String child)//父目录+子路径

public void create03() { String parent="d:\"; String child="news3.txt"; File file = new File(parent, child); try { file.createNewFile(); System.out.println("创建成功"); } catch (IOException e) { e.printStackTrace(); } } 1 2 3 4 5 6 7 8 9 10 11 🍓3.获取文件信息常用方法：

getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory

🍓4.目录操作 d:\news1.txt 是否存在，如果存在就删除

public void m1() { String filePath = "e:\news1.txt"; File file = new File(filePath); if (file.exists()) { if (file.delete()) { System.out.println(filePath + "删除成功"); } else { System.out.println(filePath + "删除失败"); } } else { System.out.println("该文件不存在..."); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 D:\demo02 是否存在，存在就删除，否则提示不存在

(在java编程中，目录也被当做文件)

public void m2() { String filePath="D:\demo2"; File file = new File(filePath); if(file.exists()) { if(file.delete()) { System.out.println(filePath+"删除成功"); }else { System.out.println(filePath+"删除失败"); } }else { System.out.println("该目录不存在..."); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 判断 D:\demo\a\b\c 目录是否存在，如果存在就提示已经存在，否则就创建

    }else {
        if(file.mkdirs()) {
        //创建一级目录使用mkdir() ，创建多级目录使用mkdirs()
            System.out.println("创建成功");
        }else {
            System.out.println("创建失败");
        }
    }

} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 🍎 二：IO流原理及分类 🍓1.简述原理 Input/Output 实现数据的输入/输出操作（以流的方式进行）

🍓2.流的分类

🍓3.FileInputStream public void readFile01() { String filePath = "d:\hello.txt"; int readData = 0; FileInputStream fileInputStream = null; try { //创建 FileInputStream 对象，用于读取文件 fileInputStream = new FileInputStream(filePath); //从该输入流读取一个字节的数据。如果没有输入可用，此方法将阻止。 //如果返回-1 , 表示读取完毕 while ((readData = fileInputStream.read()) != -1) { System.out.print((char)readData);//转成char显示 } } catch (IOException e) { e.printStackTrace(); } finally { //关闭文件流，释放资源. try { fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 单个字节的读取，效率比较低 -> 使用 read(byte[] b) public void readFile02() { String filePath = "d:\hello.txt"; //字节数组 byte[] buf = new byte[8]; //一次读取8个字节. int readLen = 0; FileInputStream fileInputStream = null; try { //创建 FileInputStream 对象，用于读取文件 fileInputStream = new FileInputStream(filePath); //从该输入流读取最多b.length字节的数据到字节数组。此方法将阻塞，直到某些输入可用。 //如果返回-1 , 表示读取完毕 //如果读取正常, 返回实际读取的字节数 while ((readLen = fileInputStream.read(buf)) != -1) { System.out.print(new String(buf, 0, readLen));//显示 }

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //关闭文件流，释放资源.
        try {
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 🍓4.FileOutputStream 请使用 FileOutputStream 在 a.txt 文件，中写入 “hello，world”. 如果文件不存在，会创建

文件(注意：前提是目录已经存在.)

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            fileOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 🍓5.作业总结1 示例1

扫描指定目录，并找到名称中包含指定字符的所有普通文件（不包含目录），并且后续询问用户是否要

删除该文件

public class Demo8 { public static void main(String[] args) throws IOException { // 1. 让用户指定一个待扫描的根目录和要查询的关键词 System.out.println("请输入要扫描的根目录(绝对路径): "); Scanner scanner = new Scanner(System.in); String root = scanner.next(); File rootDir = new File(root); if (!rootDir.isDirectory()) { System.out.println("您输入的路径错误! 程序直接退出!"); return; } System.out.println("请输入要查找的文件名中包含的关键词: "); String token = scanner.next();

    // 2. 递归的遍历目录
    //    result 表示递归遍历的结果. 就包含着所有带有 token 关键词的文件名.
    List<File> result = new ArrayList<>();
    scanDir(rootDir, token, result);
    // 3. 遍历 result, 问用户是否要删除该文件. 根据用户的输入决定是否删除
    for (File f : result) {
        System.out.println(f.getCanonicalPath() + " 是否要删除? (Y/n)");
        String input = scanner.next(); if (input.equals("Y")) {
            f.delete();
        }
    }
}

// 递归的来遍历目录, 找出里面所有符合条件的文件.
private static void scanDir(File rootDir, String token, List<File> result) throws IOException {
    // list 返回的是一个文件名(String), 使用 listFiles 直接得到的是 File 对象, 用起来更方便一些.
    File[] files = rootDir.listFiles();
    if (files == null || files.length == 0) {
        // 当前的目录是一个空的目录
        return;
    }
    for (File f : files) {
        if (f.isDirectory()) {
            // 如果当前的文件是一个目录, 就递归的进行查找
            scanDir(f, token, result);
        } else {
            // 如果当前文件是一个普通的文件, 就判定这个文件是否包含了待查找的关键词
            if (f.getName().contains(token)) {
                result.add(f.getCanonicalFile());
            }
        }
    }
}

} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 示例2

扫描指定目录，并找到名称或者内容中包含指定字符的所有普通文件（不包含目录）

注意：我们现在的方案性能较差，所以尽量不要在太复杂的目录下或者大文件下实验

public class Demo9 { public static void main(String[] args) throws IOException { Scanner scanner = new Scanner(System.in); // 1. 让用户输入一个路径. 待搜索的路径 System.out.println("请输入要扫描的根目录: "); String rootDir = scanner.next(); File rootFile = new File(rootDir); if (!rootFile.isDirectory()) { System.out.println("该目录不存在或者不是文件! 直接退出. "); return; } // 2. 再让用户输入一个查询词, 表示要搜索的结果中要包含这个词. System.out.println("请输入要查询的词: "); String query = scanner.next(); // 3. 遍历目录以及文件, 进行匹配 List results = new ArrayList<>(); scanDirWithContent(rootFile, query, results); // 4. 把结果打印出来 for (File f : results) { System.out.println(f.getCanonicalPath()); } }

private static void scanDirWithContent(File rootFile, String query, List<File> results) {
    File[] files = rootFile.listFiles();
    if (files == null || files.length == 0) {
        // 针对空的目录, 直接返回
        return;
    }
    for (File f : files) {
        if (f.isDirectory()) {
            scanDirWithContent(f, query, results);
        } else {
            if (f.getName().contains(query)) {
                // 看看文件名称中是否包含
                results.add(f);
            } else if (isContentContains(f, query)) {
                // 看看文件内容中是否包含
                results.add(f);
            }
        }
    }
}

private static boolean isContentContains(File f, String query) {
    // 打开 f 这个文件, 依次取出每一行结果, 去和 query 来进行一个 indexOf
    StringBuilder stringBuilder = new StringBuilder();
    //实现了Closeable接口的类，可以放到try（）中，自动完成资源回收
    try (InputStream inputStream = new FileInputStream(f)) {
        //用标准输入流来读取文件内容
        Scanner scanner = new Scanner(inputStream, "UTF-8");
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            stringBuilder.append(line + "\n");
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    // 只要结果不等于 -1, 就说明查到了.
    return stringBuilder.indexOf(query) != -1;
}

} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 🍓6.文件拷贝思路分析:

创建文件的输入流 , 将文件读入到程序创建文件的输出流，将读取到的文件数据，写入到指定的文件. public static void main(String[] args) { String srcfilePath="d:\大美女.jpg"; String desfilePath="d:\小美女.jpg"; FileInputStream fileInputStream=null; FileOutputStream fileOutputStream=null; try { fileInputStream= new FileInputStream(srcfilePath); fileOutputStream = new FileOutputStream(desfilePath);

        byte[]buf=new byte[1024];
        int readLen=0;
        while ((readLen=fileInputStream.read(buf))!=-1) {
            fileOutputStream.write(buf,0,readLen);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(fileInputStream!=null) fileInputStream.close();
            if(fileOutputStream!=null) fileOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 🍓7.文件字符流（FileReader、FileWriter） FileReader:

/**
 * 单个字符读取文件
 */
@Test
public void readFile01() {
    String filePath = "d:\\story.txt";
    FileReader fileReader = null;
    int data = 0;
    //1. 创建FileReader对象
    try {
        fileReader = new FileReader(filePath);
        //循环读取 使用read, 单个字符读取
        while ((data = fileReader.read()) != -1) {
            System.out.print((char) data);
        }

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

/**
 * 字符数组读取文件
 */
@Test
public void readFile02() {
    System.out.println("~~~readFile02 ~~~");
    String filePath = "d:\\story.txt";
    FileReader fileReader = null;

    int readLen = 0;
    char[] buf = new char[8];
    //1. 创建FileReader对象
    try {
        fileReader = new FileReader(filePath);
        //循环读取 使用read(buf), 返回的是实际读取到的字符数
        //如果返回-1, 说明到文件结束
        while ((readLen = fileReader.read(buf)) != -1) {
            System.out.print(new String(buf, 0, readLen));
        }

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 FileWriter:

public void fileWriter() { String filePath="d:\note.txt"; FileWriter fileWriter=null; char[]chars=new char[]{'a','b','c'}; try { fileWriter=new FileWriter(filePath); // write(int):写入单个字符 fileWriter.write('H'); // write(char[]):写入指定数组 fileWriter.write(chars); // write(char[],off,len):写入指定数组的指定部分 fileWriter.write("韩顺平教育".toCharArray(), 0, 3); // write（string）：写入整个字符串 fileWriter.write(" 你好北京~"); fileWriter.write("风雨之后，定见彩虹"); // write(string,off,len):写入字符串的指定部分 fileWriter.write("上海天津", 0, 2); //在数据量大的情况下，可以使用循环操作. } catch (IOException e) { e.printStackTrace(); } finally { try { if(fileWriter!=null) fileWriter.flush(); //fileWriter.close(); } catch (IOException e) { e.printStackTrace(); } } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 🍓8.节点流和处理流

1.节点流是底层流（低级流），直接与数据源相接。

2.处理流（包装流）对节点流进行包装，消除不同节点流的实现差异，提供更方便的方法来完成输入输出。

处理流解析：关闭处理流时，只需关闭外层流即可。

1.字符处理流 BufferedReader、BufferedWriter

BufferedReader

public void BufferedReader_() throws IOException { String filePath="d:\story.txt"; BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath)); String line; while ((line=bufferedReader.readLine())!=null) { System.out.println(line); } bufferedReader.close(); } 1 2 3 4 5 6 7 8 9 BufferedWriter

public void BufferedWriter_() throws IOException { String filePath="d:\hello.txt"; BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath)); bufferedWriter.write(""hello, 韩顺平教育!""); bufferedWriter.newLine(); bufferedWriter.write("1234"); bufferedWriter.newLine(); bufferedWriter.write("99ihsdkhf"); bufferedWriter.close(); } 1 2 3 4 5 6 7 8 9 10 综合使用，完成文本文件拷贝

注意：BufferedReader和BufferedWriter是按照字符操作，不能去操作二进制文件（图片，声音，视频，doc，pdf),否则会造成文件损坏。

public void BufferedCopy() { String srcFilePath="d:\story.txt"; String destFilePath="d:\aabbcc.txt"; BufferedReader br=null; BufferedWriter bw=null; String line; try { br=new BufferedReader(new FileReader(srcFilePath)); bw=new BufferedWriter(new FileWriter(destFilePath)); while ((line=br.readLine())!=null) { bw.write(line); bw.newLine(); } System.out.println("拷贝完毕..."); } catch (IOException e) { e.printStackTrace(); } finally { try { if(br!=null) br.close(); if(bw!=null) bw.close(); } catch (IOException e) { e.printStackTrace(); } } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 2.字节处理流 BufferedInputStream、BufferedOutputStream

public void BufferedCopy02() {
    String srcFilePath="d:\\大美女.jpg";
    String destFilePath="d:\\小美女.jpg";
    BufferedInputStream bis=null;
    BufferedOutputStream bos=null;
    try {
        bis=new BufferedInputStream(new FileInputStream(srcFilePath));
        bos=new BufferedOutputStream(new FileOutputStream(destFilePath));
        byte[]buff=new byte[1024];
        int readLen=0;
        while ((readLen=bis.read(buff))!=-1) {
            bos.write(buff,0,readLen);
        }
        System.out.println("拷贝完毕");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(bis!=null)
                bis.close();
            if(bos!=null)
                bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 3.对象处理流 ObjectOutputStream、ObjectInputStream

对数据的数据类型和数据的值都进行保存。

序列化保存数据

反序列化恢复数据

ObjectOutputStream

public class ObjectOutStream_ { public static void main(String[] args) throws Exception { //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存 String filePath = "e:\data.dat";

    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

    //序列化数据到 e:\data.dat
    oos.writeInt(100);// int -> Integer (实现了 Serializable)
    oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)
    oos.writeChar('a');// char -> Character (实现了 Serializable)
    oos.writeDouble(9.5);// double -> Double (实现了 Serializable)
    oos.writeUTF("韩顺平教育");//String
    //保存一个dog对象
    oos.writeObject(new Dog("旺财", 10, "日本", "白色"));
    oos.close();
    System.out.println("数据保存完毕(序列化形式)");
}

} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ObjectInputStream

public class ObjectInputStream_ { public static void main(String[] args) throws IOException, ClassNotFoundException { //指定反序列化的文件 String filePath="d:\test.dat"; ObjectInputStream ois=new ObjectInputStream(new FileInputStream(filePath)); //读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致 //否则会出现异常 System.out.println(ois.readInt()); System.out.println(ois.readBoolean()); System.out.println(ois.readChar()); System.out.println(ois.readDouble()); System.out.println(ois.readUTF()); System.out.println(ois.readObject()); ois.close(); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 注意事项：

读写顺序要求一致要求序列化或者反序列化的对象都需要实现Serializable接口 4.标准输入输出流

5.转换流 InputStreamReader 、OutputStreamWriter

乱码问题引出转换流的必要性：

默认读取文件按照UTF-8的形式来读取，但若文件的保存方式不是UTF-8，将会出现乱码的情况

所以需要通过转换流来指定文件的读取方式

InputStreamReader

演示使用 InputStreamReader 转换流解决中文乱码问题
将字节流 FileInputStream 转成字符流 InputStreamReader, 指定编码 gbk/utf-8 public class InputStreamReader_ { public static void main(String[] args) throws IOException { String filePath="d:\a.txt"; InputStreamReader isr=new InputStreamReader(new FileInputStream(filePath),"gbk"); BufferedReader br=new BufferedReader(isr); //上两步和在一起 //BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk")); String s= br.readLine(); System.out.println("读取内容"+s); br.close(); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 OutputStreamWriter
把FileOutputStream 字节流，转成字符流 OutputStreamWriter
指定处理的编码 gbk/utf-8/utf8 public class OutputStreamWriter_ { public static void main(String[] args) throws IOException { String filePath = "d:\hsp.txt"; String charSet = "utf-8"; OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet); osw.write("hi, 韩顺平教育"); osw.close(); System.out.println("按照 " + charSet + " 保存文件成功~"); } } 1 2 3 4 5 6 7 8 9 10 11 12 当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，建议将字节流转换为字符流

6.打印流只有输出流，没有输入流

PrintStream(字节打印流)、PrintWriter(字符打印流)

PrintStream

public class PrintStream_ { public static void main(String[] args) throws IOException { PrintStream out=new PrintStream(System.out); out.println("hello,world"); out.write("刘格你好".getBytes(StandardCharsets.UTF_8)); out.close(); //写入文件 System.setOut(new PrintStream("d:\demo.txt")); System.out.println("还得是你"); } } 1 2 3 4 5 6 7 8 9 10 11 PrintWriter

public class PrintWriter_ { public static void main(String[] args) throws IOException { PrintWriter printWriter=new PrintWriter(new FileWriter("d:\test.dat")); printWriter.write("风雨之后，定见彩虹"); printWriter.close(); } } 1 2 3 4 5 6 7 8.Properties类是专门用于读写配置文件的集合类

配置文件的格式：

键=值

代码示例：

1.使用Properties 类来读取mysql.properties 文件

public class Properties02 { public static void main(String[] args) throws IOException { //1. 创建Properties 对象 Properties properties = new Properties(); //2. 加载指定配置文件 properties.load(new FileReader("src\mysql.properties")); //3. 把k-v显示控制台 properties.list(System.out); //4. 根据key 获取对应的值 String user = properties.getProperty("user"); String pwd = properties.getProperty("pwd"); System.out.println("用户名=" + user); System.out.println("密码是=" + pwd); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 2.使用Properties 类来创建配置文件, 修改配置文件内容

public class Properties03 { public static void main(String[] args) throws IOException { Properties properties=new Properties(); //创建 //1.如果该文件没有key 就是创建 //2.如果该文件有key ,就是修改 properties.setProperty("charset", "utf8"); properties.setProperty("user", "汤姆");//注意保存时，是中文的 unicode码值 properties.setProperty("pwd", "888888"); //将k-v 存储文件中即可 properties.store(new FileWriter("src\mysql2.properties"),null); //properties.store()后边这个参数为注解 System.out.println("保存配置文件成功~"); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 🍓9.作业总结2 1:

(1) 在判断e盘下是否有文件夹mytemp ,如果没有就创建mytemp (2) 在e:\mytemp 目录下, 创建文件 hello.txt (3) 如果hello.txt 已经存在，提示该文件已经存在，就不要再重复创建了 (4) 并且在hello.txt 文件中，写入 hello,world~

使用BufferedReader读取一个文本文件，为每行加上行号，再连同内容一并输出到屏幕上。

public class HomeWork02 { public static void main(String[] args) { String filePath="d:\story.txt"; BufferedReader br=null; String line; int count=0; try { br=new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk")); while((line= br.readLine())!=null) { System.out.println(++count+" "+line); } } catch (IOException e) { e.printStackTrace(); } finally { try { if(br!=null) { br.close(); } } catch (IOException e) { e.printStackTrace(); } } } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 3:

(1) 要编写一个dog.properties name=tom age=5 color=red (2) 编写Dog 类(name,age,color) 创建一个dog对象，读取dog.properties 用相应的内容完成属性初始化, 并输出 (3) 将创建的Dog 对象，序列化到文件 d:\dog.txt 文件

public class HomeWork03 { public static void main(String[] args) throws IOException { String path="src\dog.properties"; Properties properties=new Properties(); properties.load(new FileReader(path)); String name=properties.getProperty("name"); int age= Integer.parseInt(properties.getProperty("age")); String color=properties.getProperty("color"); Dog dog=new Dog(name,age,color); System.out.println(dog); String filePath="d:\dog.txt"; ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(filePath)); oos.writeObject(dog); oos.close(); } //反序列化 @Test public void test() throws IOException, ClassNotFoundException { String filePath="d:\dog.txt"; ObjectInputStream ois=new ObjectInputStream(new FileInputStream(filePath)); Dog dog=(Dog)ois.readObject(); System.out.println(dog); ois.close(); } } class Dog implements Serializable { String name; int age; String color; public Dog(String name, int age, String color) { this.name = name; this.age = age; this.color = color; }

@Override
public String toString() {
    return "Dog{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", color='" + color + '\'' +
            '}';
}

} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 ⚡️最后的话⚡️

总结不易，希望uu们不要吝啬你们的👍哟(＾Ｕ＾)ノ~ＹＯ！！如有问题，欢迎评论区批评指正😁