Java IO流详解

小何12172024-04-30 11:26

第一部分：Java IO流的基础知识

流的分类：输入流和输出流

在Java中，所有的输入操作都由继承自InputStream的类来处理，而所有的输出操作都由继承自OutputStream的类来处理。类似地，字符流分别由Reader和Writer类来处理。

主要的流类

InputStream 和 OutputStream

  • InputStream：表示字节输入流，是Java中所有二进制输入流的顶级类。
  • OutputStream：表示字节输出流，是Java中所有二进制输出流的顶级类。

案例源码：使用InputStream和OutputStream

java 复制代码 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class StreamDemo {
    public static void main(String[] args) {
        // 创建输入流读取文件
        FileInputStream fis = new FileInputStream("input.txt");
        int data;
        try {
            // 读取数据
            while ((data = fis.read()) != -1) {
                // 将int转换为char并打印
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭流
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 创建输出流写入文件
        FileOutputStream fos = new FileOutputStream("output.txt");
        try {
            // 写入数据
            String content = "Hello, World!";
            fos.write(content.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭流
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Reader 和 Writer

  • Reader：表示字符输入流，是Java中所有字符输入流的顶级类。
  • Writer：表示字符输出流，是Java中所有字符输出流的顶级类。

案例源码：使用Reader和Writer

java 复制代码 
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class ReaderWriterDemo {
    public static void main(String[] args) {
        // 创建Reader读取文件
        FileReader reader = new FileReader("input.txt");
        char[] buffer = new char[1024];
        int length;
        try {
            // 读取数据
            while ((length = reader.read(buffer)) != -1) {
                // 打印读取的内容
                System.out.print(new String(buffer, 0, length));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭Reader
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 创建Writer写入文件
        FileWriter writer = new FileWriter("output.txt");
        try {
            // 写入数据
            String content = "Hello, World!";
            writer.write(content);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭Writer
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Java IO流的设计非常灵活，它允许开发者根据不同的IO操作选择合适的流类。字节流适合于处理二进制数据，而字符流适合于处理文本数据。字符流在处理时会使用系统默认的字符集，这使得它在处理文本文件时非常方便。

在实际编程中，应该根据数据的类型和格式选择合适的流。例如，对于图像或音频文件等二进制文件，使用字节流更为合适；而对于文本文件，使用字符流可以自动处理字符编码的转换。

此外，使用流时一定要注意异常处理和流的关闭。由于IO操作可能会抛出IOException，因此在读取或写入数据时应该使用try-catch-finally语句来确保即使在发生异常的情况下，流也能被正确关闭。这可以避免资源泄露，确保程序的健壮性。

第二部分：常用Java IO流类

字节流：FileInputStream 和 FileOutputStream

字节流用于读取和写入二进制数据。FileInputStream 用于从文件中读取字节，而 FileOutputStream 用于将字节写入文件。

案例源码：使用字节流

java 复制代码 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo {
    public static void main(String[] args) {
        File fileToRead = new File("example.bin");
        File fileToWrite = new File("copy.bin");

        try (FileInputStream fis = new FileInputStream(fileToRead);
             FileOutputStream fos = new FileOutputStream(fileToWrite)) {

            int byteData;
            while ((byteData = fis.read()) != -1) {
                fos.write(byteData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流：FileReader 和 FileWriter

字符流用于读取和写入文本数据。FileReader 用于读取文本文件，而 FileWriter 用于写入文本文件。

案例源码：使用字符流

java 复制代码 
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CharStreamDemo {
    public static void main(String[] args) {
        File fileToRead = new File("example.txt");
        File fileToWrite = new File("copy.txt");

        try (FileReader fr = new FileReader(fileToRead);
             FileWriter fw = new FileWriter(fileToWrite)) {

            int charData;
            while ((charData = fr.read()) != -1) {
                fw.write(charData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲流：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

缓冲流通过使用内部缓冲区提高IO操作的效率。对于大量数据的读写，缓冲流可以显著减少磁盘I/O操作的次数。

案例源码：使用缓冲流

java 复制代码 
import java.io.*;

public class BufferedStreamDemo {
    public static void main(String[] args) {
        String content = "Hello, Buffered World!";

        try (BufferedWriter bw = new BufferedWriter(new FileWriter("buffered.txt"))) {
            bw.write(content);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try (BufferedReader br = new BufferedReader(new FileReader("buffered.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在实际应用中，选择适当的流类型对于性能和编码的简便性至关重要。对于处理二进制数据，如图片、音频或视频文件，使用字节流是恰当的。而对于处理文本数据，字符流由于其自动处理字符编码转换的特性，通常是更好的选择。

缓冲流的使用可以显著提高IO操作的性能，尤其是在处理大量数据时。通过减少物理I/O操作的次数，缓冲流减轻了系统的负担，并提高了程序的响应速度。

在编写涉及文件操作的代码时，应该注意异常处理和资源的正确关闭。使用try-with-resources语句可以确保在代码结束时自动关闭资源，这是一种既安全又方便的做法。

第三部分：对象序列化与反序列化

ObjectInputStream 和 ObjectOutputStream

对象序列化是指将对象的状态信息转换为可以存储或传输的格式的过程。在Java中，通过实现Serializable接口，可以使一个类的对象能够被序列化。ObjectOutputStream用于将对象写入输出流，而ObjectInputStream用于从输入流中读取对象。

案例源码：对象序列化

java 复制代码 
import java.io.*;

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

    // 构造方法、getter和setter省略
}

public class SerializationDemo {
    public static void main(String[] args) {
        User user = new User();
        user.setName("Alice");
        user.setAge(25);

        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("user.obj"))) {
            oos.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 从文件中反序列化对象
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("user.obj"))) {
            User newUser = (User) ois.readObject();
            System.out.println("Name: " + newUser.getName());
            System.out.println("Age: " + newUser.getAge());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

序列化的用途和实现步骤

  1. 实现Serializable接口：使类的对象可以被序列化。
  2. 定义serialVersionUID：用于检查序列化兼容性。
  3. 使用ObjectOutputStream写入对象：将对象的序列化数据写入文件或其他输出流。
  4. 使用ObjectInputStream读取对象：从文件或其他输入流中读取对象的序列化数据，并将其转换为对象。

序列化的限制和注意事项

  • 非瞬时字段 ：只有实现了Serializable接口的类的非瞬时字段才会被序列化。
  • 静态字段：不会被序列化。
  • 序列化ID ：如果类没有显示地定义serialVersionUID，编译器会在编译时生成一个默认值。如果类的结构在后续版本中发生了变化，可能会导致序列化版本不兼容。
  • 安全性 ：不能序列化非静态成员变量的值为Thread。

个人看法：

对象序列化是Java中一个非常有用的特性，它允许将对象的状态持久化到磁盘或通过网络传输。这对于对象的长期存储和分布式系统中的数据共享非常有用。

然而，序列化也有一些限制和注意事项。例如，只有实现了Serializable接口的类才能被序列化，而且序列化过程不会包括静态字段。此外，如果类的实现发生了变化，可能会导致序列化版本不兼容，这是一个常见的问题，需要特别注意。

第四部分：Java NIO（New IO）简介

NIO与IO的区别

Java NIO（New IO）是Java IO API的后续版本，它在java.nio包下提供。NIO与IO有以下主要区别：

  • 非阻塞IO：NIO支持非阻塞模式，允许开发多反应式应用。
  • 缓冲区（Buffer）：NIO引入了缓冲区的概念，数据先被读到缓冲区，然后从缓冲区写入目标。
  • 通道（Channel）：NIO通过通道进行数据操作，通道是双向的，可以用于读取也可以用于写入。

缓冲区（Buffer）的使用

缓冲区是NIO的核心组件，用于数据的暂存。

案例源码：使用缓冲区

java 复制代码 
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;

public class BufferDemo {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        String content = "Hello, NIO!";
        buffer.put(content.getBytes(StandardCharsets.UTF_8));
        buffer.flip(); // 准备读取

        while (buffer.hasRemaining()) {
            byte b = buffer.get();
            System.out.print((char) b);
        }
    }
}

通道（Channel）的概念

通道是NIO中用于读写数据的通道。

案例源码：使用通道

java 复制代码 
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class ChannelDemo {
    public static void main(String[] args) throws IOException {
        RandomAccessFile file = new RandomAccessFile("nio-demo.txt", "rw");
        FileChannel channel = file.getChannel();

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        channel.read(buffer);
        buffer.flip();

        while (buffer.hasRemaining()) {
            System.out.print((char) buffer.get());
        }

        channel.close();
        file.close();
    }
}

文件锁和内存映射文件

NIO还提供了文件锁定和内存映射文件的能力。

  • 文件锁定 ：可以通过FileChannel的lock方法来获取文件锁。
  • 内存映射文件：允许将文件内容映射到内存中，可以提高文件访问的速度。

案例源码：内存映射文件

java 复制代码 
import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;

public class MappedFileDemo {
    public static void main(String[] args) throws IOException {
        try (RandomAccessFile file = new RandomAccessFile("nio-demo.txt", "rw")) {
            FileChannel channel = file.getChannel();
            long fileSize = channel.size();
            long position = 0;
            MappedByteBuffer buffer = channel.map(MapMode.READ_ONLY, position, fileSize);

            // 使用buffer
            for (int i = 0; i < fileSize; i++) {
                System.out.print((char) buffer.get(i));
            }
        }
    }
}

Java NIO提供了比传统IO更为强大和灵活的IO操作能力。非阻塞IO使得可以在不阻塞当前线程的情况下等待IO操作的完成，这对于开发高性能的网络应用和服务非常有利。

缓冲区和通道的组合使用，使得NIO在处理大量数据时更加高效。通过合理地使用缓冲区，可以减少系统调用的次数，提高数据传输的效率。

内存映射文件是NIO的一个高级特性，它可以提高文件访问的速度，尤其是在处理大型文件时。然而，内存映射文件也增加了程序的复杂性，需要开发者对内存管理有更深入的理解。

在使用NIO时，需要注意资源的管理和异常的处理。由于NIO的通道和缓冲区通常不是由垃圾回收器自动管理的，因此需要手动关闭它们以释放系统资源。

第五部分：Java IO流的实际应用案例

在本节中，我们将探讨Java IO流在实际应用中的几个案例，包括文件读写、数据流和对象流的应用，以及使用NIO进行高效的文件操作。

文件读写操作

文件读写是IO流最基本也是最常用的应用之一。无论是读取文本文件、写入数据，还是进行二进制文件的读写操作，Java IO流都提供了相应的解决方案。

案例源码：文本文件的读写

java 复制代码 
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class FileReadWriteDemo {
    public static void main(String[] args) {
        Path path = Path.of("example.txt");
        try {
            // 写入文本文件
            try (FileWriter writer = new FileWriter(path.toFile())) {
                writer.write("Hello, World!");
            }

            // 读取文本文件
            String content = Files.readString(path);
            System.out.println(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件读写操作是数据处理的基础。Java IO流提供了简单易用的API来处理文本文件，而NIO则提供了更高效的文件操作方式，尤其是在处理大文件时。使用Files类可以简化文件的读写操作，使得代码更加简洁。

数据流和对象流的应用

数据流和对象流允许我们以一种简单的方式来读写基本数据类型和对象。

案例源码：使用数据流读写基本数据类型

java 复制代码 
import java.io.DataOutputStream;
import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.FileInputStream;

public class DataStreamDemo {
    public static void main(String[] args) {
        try {
            // 写入数据
            try (DataOutputStream dos = new DataOutputStream(
                    new FileOutputStream("data.bin"))) {
                dos.writeInt(123);
                dos.writeDouble(45.67);
            }

            // 读取数据
            try (DataInputStream dis = new DataInputStream(
                    new FileInputStream("data.bin"))) {
                int intValue = dis.readInt();
                double doubleValue = dis.readDouble();
                System.out.println("Int: " + intValue);
                System.out.println("Double: " + doubleValue);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

数据流和对象流特别适合于需要读写固定格式数据的情况。它们简化了基本数据类型的读写操作，并且可以跨平台进行数据交换，因为它们使用了标准的字节顺序。

使用NIO进行高效的文件操作

NIO提供了更高效的文件操作方式，特别是对于大文件的处理。

案例源码：使用NIO进行文件复制

java 复制代码 
import java.nio.channels.FileChannel;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel.MapMode;

public class NioFileCopyDemo {
    public static void main(String[] args) {
        String fromFile = "source.txt";
        String toFile = "destination.txt";

        try (FileChannel inChannel = new FileInputStream(fromFile).getChannel();
             FileChannel outChannel = new FileOutputStream(toFile).getChannel()) {
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);
            while (inChannel.read(buffer) != -1) {
                buffer.flip(); // 准备读取
                outChannel.write(buffer);
                buffer.clear(); // 清除缓冲区以备下次使用
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

NIO的非阻塞特性和缓冲区的使用使得文件操作更加高效。通过使用FileChannel和ByteBuffer，可以轻松实现文件的快速复制。这种方式特别适合于处理大文件，因为它减少了内存的使用，并且可以利用系统I/O的多路复用特性。

相关推荐
程序员-珍4 分钟前
使用openapi生成前端请求文件报错 ‘Token “Integer“ does not exist.‘
java·前端·spring boot·后端·restful·个人开发
liuxin3344556622 分钟前
教育技术革新：SpringBoot在线教育系统开发
数据库·spring boot·后端
bug菌1 小时前
Java GUI编程进阶：多线程与并发处理的实战指南
java·后端·java ee
夜月行者3 小时前
如何使用ssm实现基于SSM的宠物服务平台的设计与实现+vue
java·后端·ssm
Yvemil73 小时前
RabbitMQ 入门到精通指南
开发语言·后端·ruby
sdg_advance3 小时前
Spring Cloud之OpenFeign的具体实践
后端·spring cloud·openfeign
猿java4 小时前
使用 Kafka面临的挑战
java·后端·kafka
碳苯4 小时前
【rCore OS 开源操作系统】Rust 枚举与模式匹配
开发语言·人工智能·后端·rust·操作系统·os
kylinxjd4 小时前
spring boot发送邮件
java·spring boot·后端·发送email邮件
2401_857439697 小时前
Spring Boot新闻推荐系统：用户体验优化
spring boot·后端·ux
热门推荐
01组基轨迹建模 GBTM的介绍与实现（Stata 或 R）02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04分享几个惊艳的 Three.js 个人站点05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07springer 在线投稿编译踩坑08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CTF网络安全大赛简单的web抓包题目：HEADache