深入了解Java IO

Java IO是Java中重要的一部分，也是Java应用程序中最常用的模块之一。在Java IO中，我们可以使用输入/输出流来读写数据。除此之外，Java IO还有一些强大的API，如NIO（New I/O）和文件操作库，可以提供更高效和更灵活的IO操作。

一、Java IO的基本概念

Java中的IO（输入/输出）是与外部数据源进行交互的过程，例如磁盘文件，网络连接或标准输入/输出流。Java IO API提供了诸如读/写文件和连接网络的方法，以及用于处理数据的工具类和接口。Java IO分为两种类型：字节IO和字符IO。字节IO以字节为基本单元从流中读取和写入数据，而字符IO则以字符为基本单元。每个Java IO API都实现了流处理模型，其中数据按顺序读取或写入。

Java中的IO由4个类组成：InputStream，OutputStream，Reader和Writer。InputStream和OutputStream是字节IO的基础，常用于二进制文件的读写操作；Reader和Writer是字符IO的基础，常用于文本文件的读写操作。

public class FileIOExample {
    public static void main(String[] args) {
        try {
            // 创建一个输入流
            InputStream inputStream = new FileInputStream("input.txt");

            // 创建一个输出流
            OutputStream outputStream = new FileOutputStream("output.txt");

            // 创建字符输入流
            Reader reader = new FileReader("input.txt");

            // 创建字符输出流
            Writer writer = new FileWriter("output.txt");
        } catch (IOException e) {
            System.out.println("文件IO操作出错：" + e.getMessage());
        }
    }
}

二、Java IO的流处理和缓冲

流处理模式是读/写数据的基本方式，也是Java IO技术的核心。Java中的流对象采用“管道”模式，其中从源读取数据的流被连接到输出数据的目标流。Java IO API提供了多个流类型，其中每个流对象可以读/写不同类型的数据。例如：DataInputStream是一个字节流，可以读取基本数据类型，并将它们解析为Java原语。

Java IO API还定义了一个BufferedInputStream类和BufferedOutputStream类，它们使用内存缓冲区，并通过使用缓冲区来减少文件读取和写入操作的次数，从而提高IO操作的性能。缓冲区是一块内存，用于中转数据，其中数据一次性被加载并保存在内存中，以减少IO操作对磁盘的访问。

public class BufferedFileIOExample {
    public static void main(String[] args) {
        try {
            // 创建一个输入流，使用缓冲区
            InputStream inputStream = new BufferedInputStream(new FileInputStream("input.txt"));

            // 创建一个输出流，使用缓冲区
            OutputStream outputStream = new BufferedOutputStream(new FileOutputStream("output.txt"));

            // 创建字符输入流，使用缓冲区
            Reader reader = new BufferedReader(new FileReader("input.txt"));

            // 创建字符输出流，使用缓冲区
            Writer writer = new BufferedWriter(new FileWriter("output.txt"));
        } catch (IOException e) {
            System.out.println("文件IO操作出错：" + e.getMessage());
        }
    }
}

三、Java文件操作

Java IO API提供了很多文件操作相关的类和方法。常见的文件操作包括文件读取、写入、重命名、删除等操作。

在Java文件读取过程中，经常使用FileInputStream和FileReader两个类来读取文件。FileInputStream是对文件进行字节操作的类，而FileReader是对文件进行字符操作的类。在读取文件时，可以使用Scanner，BufferedReader或InputStreamReader等类，根据实际应用场景进行选择。

/**
 * 文件操作类
 */
public class FileOperationExample {

    /**
     * 读取文件内容
     *
     * @param filePath
     */
    public static void readFile(String filePath) {
        try {
            // 使用BufferedReader类读取文件内容
            FileReader fileReader = new FileReader(filePath);
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            String line = null;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
            bufferedReader.close();
            fileReader.close();
        } catch (IOException e) {
            System.out.println("读取文件出错：" + e.getMessage());
        }
    }

    /**
     * 写入文件内容
     *
     * @param filePath
     */
    public static void writeFile(String filePath) {
        try {
            // 使用BufferedWriter类写入文件内容
            FileWriter fileWriter = new FileWriter(filePath);
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
            bufferedWriter.write("Hello World");
            bufferedWriter.newLine();
            bufferedWriter.write("Java IO");
            bufferedWriter.close();
            fileWriter.close();
        } catch (IOException e) {
            System.out.println("写入文件出错：" + e.getMessage());
        }
    }

    /**
     * 重命名文件
     *
     * @param oldFilePath
     * @param newFilePath
     */
    public static void renameFile(String oldFilePath, String newFilePath) {
        File oldFile = new File(oldFilePath);
        if (oldFile.exists()) {
            oldFile.renameTo(new File(newFilePath));
        }
    }

    /**
     * 删除文件
     *
     * @param filePath
     */
    public static void deleteFile(String filePath) {
        File file = new File(filePath);
        if (file.exists()) {
            file.delete();
        }
    }
}

四、NIO与Java IO的比较

Java IO是一种基于流的IO模型，当数据被发送或接收时，整个流都要被阻塞。这种模型不适合高负载的应用程序，因为他们需要快速地对大量数据进行读写操作。为了解决这个问题，Java NIO被引入。

Java NIO提供了一种非阻塞处理IO操作的方式，并且采用多路复用的实现方式，可以同时处理多个IO操作，提高了吞吐量和处理效率。另外，Java NIO中也提供了缓冲区，可以预读取数据，减少了IO操作对磁盘的访问。

与Java IO相比，Java NIO相对复杂。因为它有很多新的概念，如通道，选择器，缓冲区和非阻塞IO的概念。以下是Java IO和Java NIO的比较：

• Java IO：阻塞，InputStream/OutputStream、Reader/Writer，Byte/Character I/O
• Java NIO：非阻塞、I/O选择器、Channel、缓冲区、文件I/O等

public class NIOExample {
    public static void main(String[] args) throws IOException {
        // 创建文件输入流
        FileInputStream fis = new FileInputStream("input.txt");

        // 获取通道
        FileChannel channel = fis.getChannel();

        // 分配缓冲区大小
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 读取缓冲区数据
        int len = channel.read(buffer);

        while (len != -1) {
            System.out.println("Read length: " + len);
            buffer.flip();
            while (buffer.hasRemaining()) {
                System.out.print((char) buffer.get());
            }
            buffer.clear();
            len = channel.read(buffer);
        }
        fis.close();
    }
}

五、总结

Java IO是Java应用程序中最常用的模块之一，提供了读写数据的方法，包括字节IO和字符IO。Java IO API也提供了缓冲、文件操作、NIO等强大的API来提高应用程序的性能和灵活性。

除了Java IO，Java NIO非常适合高吞吐量的应用程序。Java NIO提供了一种非阻塞处理IO操作的方式，并且采用多路复用的实现方式，可以同时处理多个IO操作。