Java I/O流详解：输入输出流的基础与高级用法

最新推荐文章于 2024-09-17 11:50:15 发布

Y雨何时停T

最新推荐文章于 2024-09-17 11:50:15 发布

阅读量467

点赞数 9

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/m0_64432106/article/details/142181713

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

在Java中，I/O流（Input/Output Streams） 是处理数据读写的核心机制。无论是读取文件、发送网络请求，还是与外部设备通信，Java I/O流提供了一套强大的API，帮助开发者高效地处理数据。本文将详细介绍Java I/O流的基本概念、分类以及常见的应用场景，并涵盖一些高级用法。

1. Java I/O流概述

I/O流 是Java中用于处理输入输出操作的抽象模型。I/O流将数据看作一个连续的字节序列或字符序列，分为输入流和输出流：

输入流：用于读取数据，数据从外部资源流入到程序中。
输出流：用于写出数据，数据从程序输出到外部资源中。

Java I/O流的设计基于装饰器模式（Decorator Pattern），允许通过组合不同的流来增强功能，例如缓冲、字符编码等。

2. I/O流的分类

根据处理的数据类型和操作方式，Java的I/O流可以分为以下几类：

2.1 字节流（Byte Streams）

字节流用于处理字节级别的I/O操作，适合处理二进制数据，如图像、音频文件等。字节流的基类是InputStream和OutputStream。

InputStream：从数据源读取字节数据。
OutputStream：将字节数据写入到数据目标中。

常见的字节流类有：

FileInputStream：从文件读取字节数据。
FileOutputStream：将字节数据写入文件。

示例：使用字节流读写文件

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

public class ByteStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);  // 将每个字节写入输出文件
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，FileInputStream读取字节数据，FileOutputStream将这些数据写入到另一个文件。

2.2 字符流（Character Streams）

字符流用于处理字符级别的I/O操作，适合处理文本文件。字符流的基类是Reader和Writer。

Reader：用于读取字符数据。
Writer：用于写出字符数据。

常见的字符流类有：

FileReader：从文件读取字符数据。
FileWriter：将字符数据写入文件。

示例：使用字符流读写文件

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

public class CharacterStreamExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("input.txt");
             FileWriter writer = new FileWriter("output.txt")) {
            int data;
            while ((data = reader.read()) != -1) {
                writer.write(data);  // 将每个字符写入输出文件
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流会自动处理字符编码问题，适合处理纯文本文件。

2.3 缓冲流（Buffered Streams）

缓冲流是一种带有缓冲区的I/O流，用于提高读写效率。缓冲流不会一次处理一个字节或字符，而是将数据存入缓冲区，然后批量读取或写入，减少实际I/O操作的次数。

BufferedInputStream 和 BufferedOutputStream：为字节流提供缓冲功能。
BufferedReader 和 BufferedWriter：为字符流提供缓冲功能，常用于读取和写入文本文件。

示例：使用缓冲流提高性能

import java.io.*;

public class BufferedStreamExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
             BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();  // 写入新行
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲流通过减少对文件系统的直接访问次数，极大提高了性能，尤其是在处理大文件时。

2.4 数据流（Data Streams）

数据流允许读写基本数据类型（如int、double、boolean等）而不需要手动进行转换。它们提供了对基本类型的高效处理。

DataInputStream：允许从输入流中读取基本数据类型。
DataOutputStream：允许将基本数据类型写入输出流。

示例：使用数据流读写基本类型

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamExample {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"))) {
            dos.writeInt(100);
            dos.writeDouble(99.99);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try (DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"))) {
            int i = dis.readInt();
            double d = dis.readDouble();
            System.out.println("Read values: " + i + ", " + d);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这种方式避免了手动处理数据转换问题，简化了读取和写入操作。

2.5 对象流（Object Streams）

对象流用于处理对象的序列化和反序列化操作。通过对象流，Java对象可以被转换为字节流存储到文件中，或者通过网络传输。对象流类包括：

ObjectInputStream：从输入流中读取对象。
ObjectOutputStream：将对象写入输出流。

对象流要求所有被序列化的对象类必须实现Serializable接口。

示例：使用对象流进行对象序列化

import java.io.*;

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

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

public class ObjectStreamExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);

        // 序列化对象
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化对象
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person deserializedPerson = (Person) ois.readObject();
            System.out.println("Deserialized Person: " + deserializedPerson.name + ", " + deserializedPerson.age);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们将一个Person对象序列化到文件中，然后从文件中反序列化回对象。

3. I/O流的常见应用场景

3.1 文件读取与写入

最常见的I/O场景是读取文件内容和将数据写入文件。字节流和字符流都可以用于文件操作，具体取决于处理的是二进制数据还是文本数据。

3.2 网络通信

Java的I/O流还可以用于处理网络通信。通过Socket类，程序可以建立网络连接，并使用I/O流读取和发送数据。例如，通过InputStream读取服务器的响应，通过OutputStream向服务器发送请求。

3.3 数据序列化

通过对象流，Java对象可以持久化到文件中，或者通过网络发送。序列化和反序列化使得Java对象可以在不同程序或系统之间进行传输。

3.4 数据处理与传输

对于数据分析和处理场景，I/O流可以处理大量的原始数据，例如读取传感器数据、处理文件中的记录或将数据发送到远程服务器。

4. 高级用法：Java NIO

除了传统的I/O流，Java 1.4引入了**NIO（New I/O）**库，提供了更加高效的I

/O操作。NIO引入了通道（Channels）、**缓冲区（Buffers）和选择器（Selectors）**等概念，实现了非阻塞的I/O操作，特别适合高并发的网络编程。

4.1 与I/O流的对比

传统I/O流是阻塞的，读写操作会阻塞程序，直到操作完成。
NIO允许非阻塞I/O，程序可以在等待数据时执行其他操作，适合需要处理大量并发连接的应用。

示例：使用NIO读取文件

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;

public class NIOExample {
    public static void main(String[] args) {
        try (FileChannel fileChannel = FileChannel.open(Path.of("input.txt"), StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while (fileChannel.read(buffer) > 0) {
                buffer.flip();  // 准备从缓冲区读取数据
                while (buffer.hasRemaining()) {
                    System.out.print((char) buffer.get());  // 输出读取到的字符
                }
                buffer.clear();  // 清空缓冲区，准备下一次读取
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}