Java IO流：从字节流到字符流

输出结果：如果test.txt文件的内容是'Hello, Java!'，则输出'Hello, Java!'。

输出字节流

输出字节流的基类是OutputStream，常用的实现类包括FileOutputStream、ByteArrayOutputStream等。

FileOutputStream

定义：FileOutputStream是用于写入文件内容的输出字节流。

创建对象：

FileOutputStream fos = new FileOutputStream("文件路径");

示例：

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

public class TestFileOutputStream {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("test.txt")) {
            String str = "Hello, Java!";
            fos.write(str.getBytes());
            System.out.println("文件写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出结果：输出'文件写入成功！'，并在test.txt文件中写入'Hello, Java!'。

字符流

字符流分为输入字符流和输出字符流。

输入字符流

输入字符流的基类是Reader，常用的实现类包括FileReader、CharArrayReader等。

FileReader

定义：FileReader是用于读取文本文件内容的输入字符流。

创建对象：

FileReader fr = new FileReader("文件路径");

示例：

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

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

输出结果：如果test.txt文件的内容是'Hello, Java!'，则输出'Hello, Java!'。

输出字符流

输出字符流的基类是Writer，常用的实现类包括FileWriter、CharArrayWriter等。

FileWriter

定义：FileWriter是用于写入文本文件内容的输出字符流。

创建对象：

FileWriter fw = new FileWriter("文件路径");

示例：

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

public class TestFileWriter {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("test.txt")) {
            String str = "Hello, Java!";
            fw.write(str);
            System.out.println("文件写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出结果：输出'文件写入成功！'，并在test.txt文件中写入'Hello, Java!'。

处理流

处理流是对节点流进行包装的流，用于提高输入和输出效率。

缓冲流

缓冲流分为缓冲字节流和缓冲字符流，用于提高输入和输出效率。

缓冲字节流

定义：缓冲字节流是对字节流进行包装的流，包括BufferedInputStream和BufferedOutputStream。

创建对象：

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("文件路径"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("文件路径"));

示例：

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

public class TestBufferedStream {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.txt"));
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test_copy.txt"))) {
            int data;
            while ((data = bis.read()) != -1) {
                bos.write(data);
            }
            System.out.println("文件复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出结果：输出'文件复制成功！'，并在test_copy.txt文件中写入'Hello, Java!'。

缓冲字符流

定义：缓冲字符流是对字符流进行包装的流，包括BufferedReader和BufferedWriter。

创建对象：

BufferedReader br = new BufferedReader(new FileReader("文件路径"));
BufferedWriter bw = new BufferedWriter(new FileWriter("文件路径"));

示例：

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

public class TestBufferedReaderWriter {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"));
             BufferedWriter bw = new BufferedWriter(new FileWriter("test_copy.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
            System.out.println("文件复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出结果：输出'文件复制成功！'，并在test_copy.txt文件中写入'Hello, Java!'。

✅ 结论：缓冲流可以提高输入和输出效率，建议在实际开发中使用缓冲流。

转换流

转换流分为InputStreamReader和OutputStreamWriter，用于在字节流和字符流之间进行转换。

InputStreamReader

定义：InputStreamReader是用于将字节流转换为字符流的流。

创建对象：

InputStreamReader isr = new InputStreamReader(new FileInputStream("文件路径"), "字符编码");

示例：

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

public class TestInputStreamReader {
    public static void main(String[] args) {
        try (InputStreamReader isr = new InputStreamReader(new FileInputStream("test.txt"), "UTF-8")) {
            int data;
            while ((data = isr.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出结果：如果test.txt文件的内容是'Hello, Java!'，则输出'Hello, Java!'。

OutputStreamWriter

定义：OutputStreamWriter是用于将字符流转换为字节流的流。

创建对象：

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("文件路径"), "字符编码");

示例：

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

public class TestOutputStreamWriter {
    public static void main(String[] args) {
        try (OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("test.txt"), "UTF-8")) {
            String str = "Hello, Java!";
            osw.write(str);
            System.out.println("文件写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出结果：输出'文件写入成功！'，并在test.txt文件中写入'Hello, Java!'。

对象流

对象流分为ObjectInputStream和ObjectOutputStream，用于将对象序列化和反序列化。

序列化

定义：序列化是将对象转换为字节流的过程。

示例：

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

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

public class TestObjectOutputStream {
    public static void main(String[] args) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"))) {
            Person person = new Person("张三", 20);
            oos.writeObject(person);
            System.out.println("对象序列化成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出结果：输出'对象序列化成功！'，并在person.txt文件中写入序列化后的对象。

反序列化

定义：反序列化是将字节流转换为对象的过程。

示例：

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

public class TestObjectInputStream {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"))) {
            Person person = (Person) ois.readObject();
            System.out.println("对象反序列化成功！");
            System.out.println(person);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出结果：输出'对象反序列化成功！'和'Person{name='张三', age=20}'。

⚠️ 注意：要使对象可序列化，类必须实现Serializable接口。

文件操作

Java提供了File类，用于操作文件和目录。

File类的使用

示例：

import java.io.File;
import java.io.IOException;

public class TestFile {
    public static void main(String[] args) {
        // 创建文件对象
        File file = new File("test.txt");

        // 判断文件是否存在
        if (file.exists()) {
            System.out.println("文件已存在！");
        } else {
            System.out.println("文件不存在！");
            try {
                file.createNewFile();
                System.out.println("文件创建成功！");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 判断是否是文件
        System.out.println("是否是文件：" + file.isFile());

        // 判断是否是目录
        System.out.println("是否是目录：" + file.isDirectory());

        // 获取文件的名称
        System.out.println("文件的名称：" + file.getName());

        // 获取文件的路径
        System.out.println("文件的路径：" + file.getPath());

        // 获取文件的绝对路径
        System.out.println("文件的绝对路径：" + file.getAbsolutePath());

        // 获取文件的大小
        System.out.println("文件的大小：" + file.length() + "字节");

        // 删除文件
        if (file.delete()) {
            System.out.println("文件删除成功！");
        } else {
            System.out.println("文件删除失败！");
        }
    }
}

输出结果：

文件不存在！
文件创建成功！
是否是文件：true
是否是目录：false
文件的名称：test.txt
文件的路径：test.txt
文件的绝对路径：C:\Users\Administrator\Desktop\test.txt
文件的大小：0字节
文件删除成功！

总结

本章我们学习了Java的IO流，包括字节流和字符流。其中，字节流（FileInputStream、FileOutputStream）、字符流（FileReader、FileWriter）、缓冲流（BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter）是本章的重点内容。