Java IO入门

前言

Java I/O知识概览

在日常工作中，我们经常需要进行文件操作和网络操作等任务。作为开发人员，了解和掌握Java I/O相关知识是优化系统性能和效率的关键。

Java I/O处理方式

Java提供了多种I/O处理方式，包括：

1. Java IO：基于阻塞模式的流式操作，适用于连接数较少且处理顺序的场景。
2. Java NIO：面向缓冲区的非阻塞I/O操作，通过使用Channel、Buffer和Selector等API，实现了多路复用和高并发处理能力。
3. Java NIO.2：在Java NIO的基础上引入了更多特性和API，提供了便捷的文件操作和异步I/O操作。
4. Java异步IO：通过使用CompletableFuture和Flow API实现异步I/O操作，提高系统吞吐量和性能。

重要性和应用场景

了解和掌握Java I/O相关知识对于性能优化和系统设计非常重要。根据不同的场景和需求，我们可以选择适当的I/O方式来提高系统效率和响应能力。

总结：Java I/O知识概览提供了多种处理方式，每种方式都有其特点和适用场景。了解和掌握这些知识有助于我们优化系统性能和提高工作效率。

Java的I/O演进之路

Java的I/O演进之路经历了多个版本的迭代和改进，主要包括经典的Java IO（JDK 1.0）、Java NIO（JDK 1.4）、Java NIO.2（JDK 7）和Java异步IO（JDK 9）。

Java IO（JDK 1.0）

• 特点：基于阻塞模式的流式操作
• 主要API：InputStream、OutputStream、Reader、Writer
• 应用场景：连接数较少且处理顺序的场景

Java NIO（JDK 1.4）

• 特点：面向缓冲区的非阻塞I/O操作，提供了选择器实现多路复用
• 主要API：Channel、Buffer、Selector
• 应用场景：高并发、大量连接和需要灵活处理的场景

Java NIO.2（JDK 7）

• 特点：引入了更多的特性和API，提供更便捷的文件操作和异步I/O操作
• 主要API：Path、File、AsynchronousFileChannel
• 应用场景：更复杂的I/O操作和文件操作

Java异步IO（JDK 9）

• 特点：通过CompletableFuture和Flow API实现异步I/O操作，提高系统吞吐量和性能
• 主要API：CompletableFuture、Flow
• 应用场景：高并发和大量连接的场景，需要更高级的异步操作方式

总的来说，Java的I/O演进之路从最早的阻塞I/O到非阻塞I/O和异步I/O的发展，逐步提高了Java在I/O处理上的性能和灵活性，使得Java在处理大规模并发连接时更加高效和可扩展。

版本/名称	主要特点	应用场景
Java IO（JDK 1.0）	阻塞模式的流式操作	连接数较少且处理顺序的场景
Java NIO（JDK 1.4）	面向缓冲区的非阻塞I/O操作，提供了选择器实现多路复用	高并发、大量连接和需要灵活处理的场景
Java NIO.2（JDK 7）	引入了更多的特性和API，提供更便捷的文件操作和异步I/O操作	更复杂的I/O操作和文件操作
Java异步IO（JDK 9）	通过CompletableFuture和Flow API实现异步I/O操作，提高系统吞吐量和性能	高并发和大量连接的场景，需要更高级的异步操作

Java I/O 代码示例

常用对象

下面是一个java体系的简单表格:

类/接口	描述
InputStream	字节输入流的抽象基类
OutputStream	字节输出流的抽象基类
Reader	字符输入流的抽象基类
Writer	字符输出流的抽象基类
FileInputStream	从文件中读取字节的流
FileOutputStream	向文件中写入字节的流
FileReader	从文件中读取字符的流
FileWriter	向文件中写入字符的流
BufferedInputStream	提供缓冲功能的字节输入流
BufferedOutputStream	提供缓冲功能的字节输出流
BufferedReader	提供缓冲功能的字符输入流
BufferedWriter	提供缓冲功能的字符输出流
DataInputStream	读取基本数据类型的流
DataOutputStream	写入基本数据类型的流
ObjectInputStream	读取对象的流
ObjectOutputStream	写入对象的流
PrintStream	用于打印输出的流

BIO代码示例

以下是一些Java IO示例代码：

读取文件内容：

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

写入文件内容：

try (BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"))) {
    String content = "Hello, World!";
    writer.write(content);
} catch (IOException e) {
    e.printStackTrace();
}

复制文件：

try (InputStream inputStream = new FileInputStream("source.txt");
     OutputStream outputStream = new FileOutputStream("target.txt")) {
    byte[] buffer = new byte[1024];
    int length;
    while ((length = inputStream.read(buffer)) != -1) {
        outputStream.write(buffer, 0, length);
    }
} catch (IOException e) {
    e.printStackTrace();
}

使用缓冲区读取文件：

try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream("file.txt"))) {
    byte[] buffer = new byte[1024];
    int length;
    while ((length = inputStream.read(buffer)) != -1) {
        // 处理读取的数据
    }
} catch (IOException e) {
    e.printStackTrace();
}

这些示例代码展示了如何使用Java IO进行文件读写和复制操作。根据具体的需求，可以选择合适的IO类和方法来实现相应的功能。

AIO代码示例

以下是一个使用Java异步IO的示例代码：

public class AsyncIOExample {
    public static void main(String[] args) {
        AsynchronousFileChannel fileChannel = null;
        try {
            Path filePath = new File("file.txt").toPath();
            fileChannel = AsynchronousFileChannel.open(
                    filePath, StandardOpenOption.READ);

            ByteBuffer buffer = ByteBuffer.allocate(1024);
            long position = 0;

            // 异步读取文件
            Future<Integer> readResult = fileChannel.read(buffer, position);
            while (!readResult.isDone()) {
                // 可以在这里做其他事情
                System.out.println("正在读取文件...");
            }

            // 处理读取结果
            int bytesRead = readResult.get();
            if (bytesRead != -1) {
                buffer.flip();
                byte[] data = new byte[buffer.limit()];
                buffer.get(data);
                String content = new String(data);
                System.out.println("读取的文件内容：");
                System.out.println(content);
            }

            // 异步写入文件
            String newData = "Hello, World!";
            buffer.clear();
            buffer.put(newData.getBytes());
            buffer.flip();

            Future<Integer> writeResult = fileChannel.write(buffer, position);
            while (!writeResult.isDone()) {
                // 可以在这里做其他事情
                System.out.println("正在写入文件...");
            }

            // 处理写入结果
            int bytesWritten = writeResult.get();
            System.out.println("已写入 " + bytesWritten + " 字节到文件。");
        } catch (IOException | InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            if (fileChannel != null) {
                try {
                    fileChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

这个示例展示了如何使用Java的异步IO（Asynchronous IO）来进行文件读取和写入操作。使用AsynchronousFileChannel来打开文件通道，然后可以异步地执行读取和写入操作。通过使用Future来获取异步操作的结果。

在示例中，我们首先异步读取文件内容，然后处理读取的结果。接着，我们异步写入新的数据到文件，并处理写入的结果。最后，关闭文件通道。

结合CompletableFuture:

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.CompletableFuture;

public class CompletableFutureAsyncIOExample {

    public static void main(String[] args) {
        try {
            Path filePath = new File("file.txt").toPath();
            AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(filePath, StandardOpenOption.READ);

            CompletableFuture<Integer> future = new CompletableFuture<>();
            ByteBuffer buffer = ByteBuffer.allocate(1024);

            fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                @Override
                public void completed(Integer result, ByteBuffer attachment) {
                    // 读取成功时调用的回调函数
                    future.complete(result);
                }

                @Override
                public void failed(Throwable exc, ByteBuffer attachment) {
                    // 读取失败时调用的回调函数
                    future.completeExceptionally(exc);
                }
            });

            future.thenAccept(result -> {
                // 读取完成后的处理逻辑
                System.out.println("Read " + result + " bytes from file.");
                byte[] data = new byte[result];
                buffer.flip();
                buffer.get(data);
                System.out.println("Data: " + new String(data));
            });

            // 阻塞主线程，等待读取完成
            future.join();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

上述代码中，我们首先使用AsynchronousFileChannel打开一个文件通道，然后创建一个CompletableFuture对象来表示异步读取操作的结果。接下来，我们调用read方法来异步读取文件内容，并传入一个CompletionHandler对象作为回调函数。在回调函数中，我们根据读取的结果调用complete或completeExceptionally方法来完成CompletableFuture。最后，我们使用thenAccept方法设置一个回调函数，在读取完成后对结果进行处理。

通过CompletableFuture结合异步IO，我们可以实现非阻塞的IO操作，并利用回调函数处理读取结果。这种方式可以提高系统的并发性能，使程序更加高效。

NIO

NIO定义及特性

NIO（New I/O）是Java提供的一种基于通道和缓冲区的IO模型，相对于传统的IO流，它提供了更高效和灵活的IO操作方式。

NIO的核心概念包括：

1.通道（Channel）：通道是数据源和数据目的地之间的连接，可以进行读取和写入操作。通道可以是文件、网络套接字、管道等。不同类型的通道提供了不同的功能和特性。

2.缓冲区（Buffer）：缓冲区是用于存储数据的一块内存区域。NIO使用缓冲区与通道进行数据交互。缓冲区提供了不同数据类型的方法来读取和写入数据，以及跟踪读写位置和限制。

3.选择器（Selector）：选择器是NIO的核心组件之一，它提供了一种高效的多路复用方式，使一个线程可以监听多个通道的事件。通过选择器，可以实现单线程处理多个通道的IO操作，提高系统的性能和扩展性。

NIO的主要优势在于它的非阻塞特性。与传统的IO流不同，NIO使用非阻塞IO模型，可以实现一个线程处理多个通道的IO操作，而不需要为每个通道创建一个独立的线程。这使得NIO在处理大量的并发连接时更加高效和可扩展。

NIO还提供了一些高级的组件和特性，如文件锁定、内存映射文件、异步IO等，可以满足更复杂的IO需求。

总之，NIO是Java提供的一种更高级、更灵活的IO模型，适用于处理高并发、高性能的IO操作。它通过通道和缓冲区的概念，以及选择器的多路复用方式，使得Java程序能够更好地处理IO操作。

代码示例

读取文件：

try {
            // 打开文件通道
            FileChannel fileChannel = FileChannel.open(
                    new File("file.txt").toPath(), StandardOpenOption.READ);

            // 创建缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(1024);

            // 读取文件内容到缓冲区
            int bytesRead = fileChannel.read(buffer);
            while (bytesRead != -1) {
                buffer.flip(); // 切换读模式
                while (buffer.hasRemaining()) {
                    System.out.print((char) buffer.get()); // 打印读取的字符
                }
                buffer.clear(); // 清空缓冲区
                bytesRead = fileChannel.read(buffer);
            }

            // 关闭文件通道
            fileChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

文件写入：

try {
            // 打开文件通道
            FileChannel fileChannel = FileChannel.open(
                    new Path("output.txt").toPath(), StandardOpenOption.CREATE, StandardOpenOption.WRITE);

            // 创建缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put("Hello, World!".getBytes());
            buffer.flip(); // 切换到读模式

            // 写入文件
            fileChannel.write(buffer);

            // 关闭文件通道
            fileChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

通道间的数据传输示例：

try {
            // 打开源文件通道
            FileChannel sourceChannel = FileChannel.open(
                    new File("source.txt").toPath(), StandardOpenOption.READ);

            // 打开目标文件通道
            FileChannel targetChannel = FileChannel.open(
                    new File("target.txt").toPath(), StandardOpenOption.CREATE, StandardOpenOption.WRITE);

            // 传输数据
            sourceChannel.transferTo(0, sourceChannel.size(), targetChannel);

            // 关闭通道
            sourceChannel.close();
            targetChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
/** NIO的通道间数据传输是一种高效的方式，可以在不使用中间缓冲区的情况下直接将数据从一个通道传输到另一个通道。这种方式可以在不占用过多内存的情况下快速地将数据从一个位置复制到另一个位置。以下是一些使用NIO通道间数据传输的示例：

	1.文件复制：可以使用transferTo()或transferFrom()方法将一个文件的内容直接传输到另一个文件，			    而无需显式地读取和写入数据。
	2.网络传输：可以使用SocketChannel和ServerSocketChannel之间的数据传输来实现高效的网络通信。例如，可以将数据从一个客户端的SocketChannel传输到服务器的ServerSocketChannel，或者反过来。

	3.内存映射文件：可以使用FileChannel在内存和文件之间创建映射，然后使用通道间的数据传输来高效	地读取和写入数据。

	4.数据库操作：可以使用FileChannel和SocketChannel之间的数据传输来将数据直接从数据库读取并传输到另一个地方，或者将数据传输到数据库中。

多线程数据共享：可以使用Pipe和Pipe.SinkChannel、Pipe.SourceChannel之间的数据传输来实现多线程之间的数据共享和通信。

通过使用NIO通道间的数据传输，可以避免使用中间缓冲区，减少内存消耗，并提高数据传输的效率。这种方式特别适用于需要高性能和低延迟的场景，如大文件处理、网络编程和并发数据共享等。**/

文件锁定示例：

try {
            // 打开文件通道
            FileChannel fileChannel = FileChannel.open(
                    new File("file.txt").toPath(), StandardOpenOption.WRITE);

            // 获取文件锁定
            FileLock fileLock = fileChannel.lock();

            // 执行操作（文件锁定期间，其他进程无法对文件进行写入操作）

            // 释放文件锁定
            fileLock.release();

            // 关闭文件通道
            fileChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

selector多路复用示例：

try {
            // 创建ServerSocketChannel
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress(8080));
            serverSocketChannel.configureBlocking(false);

            // 创建Selector
            Selector selector = Selector.open();

            // 将ServerSocketChannel注册到Selector，监听OP_ACCEPT事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            while (true) {
                // 阻塞等待事件
                selector.select();

                // 处理事件
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    if (selectionKey.isAcceptable()) {
                        // 处理连接请求
                        SocketChannel socketChannel = serverSocketChannel.accept();
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector, SelectionKey.OP_READ);
                    } else if (selectionKey.isReadable()) {
                        // 处理读取请求
                        SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        socketChannel.read(buffer);
                        buffer.flip();
                        String request = new String(buffer.array(), 0, buffer.limit());
                        System.out.println("Request from client: " + request);
                        socketChannel.register(selector, SelectionKey.OP_WRITE);
                    } else if (selectionKey.isWritable()) {
                        // 处理写入请求
                        SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                        String response = "Hello, Client!";
                        ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                        socketChannel.write(buffer);
                        socketChannel.close();
                    }
                    iterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

多路复用可以被形象地描述为一条高速公路上的多车道行驶。在传统的通信方式中，每个请求都需要使用独立的连接进行传输，就像每辆车都需要独占一条车道。而多路复用则类似于在高速公路上开辟多个车道，多辆车可以同时行驶，共享同一个道路资源。

当多个请求需要发送到同一个服务器时，使用多路复用可以将这些请求打包在同一个连接中进行传输，而不是为每个请求创建独立的连接。这样就可以减少连接的建立和关闭的开销，并提高数据传输的效率。