重生之我在deepseek中学习java 第九天之输入输出（I/O）-Java-E先生的博客

Java学习指南-第九天：输入输出（I/O）操作

　　1.I/O流简介

　　Java的I/O流用于处理输入和输出操作。I/O流可以分为字节流和字符流：

　　字节流：以字节为单位进行读写操作，主要用于处理二进制数据。

　　字符流：以字符为单位进行读写操作，主要用于处理文本数据。

　　2.字节流

　　字节流的核心类是InputStream和OutputStream。

　　2.1 FileInputStream和FileOutputStream

　　FileInputStream用于从文件中读取字节，FileOutputStream用于向文件中写入字节。

　　2.1.1读取文件

import java.io.FileInputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　2.1.2写入文件

import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            String text = "Hello, World!";
            fos.write(text.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　2.2 BufferedInputStream和BufferedOutputStream

　　BufferedInputStream和BufferedOutputStream是带缓冲区的字节流，可以提高读写效率。

　　2.2.1读取文件　　

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"))) {
            int data;
            while ((data = bis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　2.2.2写入文件

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
            String text = "Hello, World!";
            bos.write(text.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　3.字符流

　　字符流的核心类是Reader和Writer。

　　3.1 FileReader和FileWriter

　　FileReader用于从文件中读取字符，FileWriter用于向文件中写入字符。

　　3.1.1读取文件

import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("input.txt")) {
            int data;
            while ((data = fr.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　3.1.2写入文件

import java.io.FileWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("output.txt")) {
            String text = "Hello, World!";
            fw.write(text);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　3.2 BufferedReader和BufferedWriter

　　BufferedReader和BufferedWriter是带缓冲区的字符流，可以提高读写效率。

　　3.2.1读取文件

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　3.2.2写入文件

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            String text = "Hello, World!";
            bw.write(text);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　4.对象序列化与反序列化

　　对象序列化是将对象转换为字节流的过程，反序列化是将字节流转换回对象的过程。Java提供了ObjectInputStream和ObjectOutputStream来实现对象的序列化和反序列化。

　　4.1序列化对象

　　import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Main {
    public static void main(String[] args) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"))) {
            Person person = new Person("John", 30);
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

　　4.2反序列化对象

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Main {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"))) {
            Person person = (Person) ois.readObject();
            System.out.println(person);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

　　5.今日任务

　　使用FileInputStream和FileOutputStream读取和写入一个二进制文件。

　　使用BufferedReader和BufferedWriter读取和写入一个文本文件。

　　定义一个Student类，实现Serializable接口，并对其进行序列化和反序列化操作。

　　6.示例代码　　

import java.io.*;

public class Main {
    public static void main(String[] args) {
        // 任务1：使用FileInputStream和FileOutputStream
        try (FileInputStream fis = new FileInputStream("input.bin");
             FileOutputStream fos = new FileOutputStream("output.bin")) {
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 任务2：使用BufferedReader和BufferedWriter
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
             BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 任务3：序列化和反序列化Student对象
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student.txt"))) {
            Student student = new Student("Alice", 20);
            oos.writeObject(student);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student.txt"))) {
            Student student = (Student) ois.readObject();
            System.out.println(student);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Student implements Serializable {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

　　7.总结

　　今天的内容涵盖了Java的输入输出操作，包括字节流、字符流、缓冲流以及对象的序列化和反序列化。I/O操作是Java编程中非常重要的一部分，务必熟练掌握。明天我们将深入学习多线程编程。

　　提示：多动手编写代码，尝试使用不同的I/O流进行文件读写操作，理解它们的特点和适用场景。

　　祝你学习愉快！