Java IO流基础知识与竞赛应用深度解析

IO流的基本概念：数据从源（Source）流向目标（Destination）

输入流体系：
InputStream（字节输入流抽象类）
├── FileInputStream（文件字节输入流）
├── ByteArrayInputStream（字节数组输入流）
├── PipedInputStream（管道输入流）
├── FilterInputStream（过滤输入流抽象类）
│   ├── BufferedInputStream（缓冲输入流）
│   ├── DataInputStream（数据输入流）
│   └── ObjectInputStream（对象输入流）

Reader（字符输入流抽象类）
├── FileReader（文件字符输入流）
├── CharArrayReader（字符数组输入流）
├── PipedReader（管道输入流）
├── FilterReader（过滤输入流抽象类）
│   └── BufferedReader（缓冲输入流）
└── InputStreamReader（输入流转换为字符流）
    └── FileReader（文件字符输入流）

输出流体系：
OutputStream（字节输出流抽象类）
├── FileOutputStream（文件字节输出流）
├── ByteArrayOutputStream（字节数组输出流）
├── PipedOutputStream（管道输出流）
├── FilterOutputStream（过滤输出流抽象类）
│   ├── BufferedOutputStream（缓冲输出流）
│   ├── DataOutputStream（数据输出流）
│   └── ObjectOutputStream（对象输出流）

Writer（字符输出流抽象类）
├── FileWriter（文件字符输出流）
├── CharArrayWriter（字符数组输出流）
├── PipedWriter（管道输出流）
├── FilterWriter（过滤输出流抽象类）
│   └── BufferedWriter（缓冲输出流）
└── OutputStreamWriter（输出流转换为字符流）
    └── FileWriter（文件字符输出流）

字节流的处理单位：1字节（8位二进制数）

// 使用FileInputStream读取文件
public static void readFile(String filePath) throws IOException {
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(filePath);
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = fis.read(buffer)) != -1) {
            // 处理读取的数据
            System.out.print(new String(buffer, 0, bytesRead));
        }
    } finally {
        if (fis != null) {
            fis.close();
        }
    }
}

// 使用FileOutputStream写入文件
public static void writeFile(String filePath, String content) throws IOException {
    FileOutputStream fos = null;
    try {
        fos = new FileOutputStream(filePath);
        byte[] data = content.getBytes();
        fos.write(data);
        fos.flush(); // 刷新缓冲区
    } finally {
        if (fos != null) {
            fos.close();
        }
    }
}

// 使用ByteArrayInputStream读取字节数组
public static void readByteArray(byte[] data) {
    ByteArrayInputStream bais = new ByteArrayInputStream(data);
    int byteRead;
    while ((byteRead = bais.read()) != -1) {
        // 处理读取的字节
        System.out.print((char) byteRead);
    }
    bais.close();
}

// 使用ByteArrayOutputStream写入字节数组
public static byte[] writeByteArray(String content) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] data = content.getBytes();
    try {
        baos.write(data);
        return baos.toByteArray();
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    } finally {
        try {
            baos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流的处理单位：1字符（通常为2字节或4字节，取决于编码方式）

// 使用FileReader读取文件
public static void readFileWithReader(String filePath) throws IOException {
    FileReader fr = null;
    try {
        fr = new FileReader(filePath);
        char[] buffer = new char[1024];
        int charsRead;
        while ((charsRead = fr.read(buffer)) != -1) {
            // 处理读取的数据
            System.out.print(new String(buffer, 0, charsRead));
        }
    } finally {
        if (fr != null) {
            fr.close();
        }
    }
}

// 使用FileWriter写入文件
public static void writeFileWithWriter(String filePath, String content) throws IOException {
    FileWriter fw = null;
    try {
        fw = new FileWriter(filePath);
        fw.write(content);
        fw.flush(); // 刷新缓冲区
    } finally {
        if (fw != null) {
            fw.close();
        }
    }
}

// 使用CharArrayReader读取字符数组
public static void readCharArray(char[] data) {
    CharArrayReader car = new CharArrayReader(data);
    int charRead;
    while ((charRead = car.read()) != -1) {
        // 处理读取的字符
        System.out.print((char) charRead);
    }
    car.close();
}

// 使用CharArrayWriter写入字符数组
public static char[] writeCharArray(String content) {
    CharArrayWriter caw = new CharArrayWriter();
    try {
        caw.write(content);
        return caw.toCharArray();
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    } finally {
        caw.close();
    }
}

缓冲流的工作原理：程序 → 缓冲区 → 底层设备

// 使用BufferedInputStream读取文件
public static void readFileWithBufferedStream(String filePath) throws IOException {
    BufferedInputStream bis = null;
    try {
        bis = new BufferedInputStream(new FileInputStream(filePath));
        byte[] buffer = new byte[8192]; // 8KB缓冲区
        int bytesRead;
        while ((bytesRead = bis.read(buffer)) != -1) {
            // 处理读取的数据
            System.out.print(new String(buffer, 0, bytesRead));
        }
    } finally {
        if (bis != null) {
            bis.close();
        }
    }
}

// 使用BufferedOutputStream写入文件
public static void writeFileWithBufferedStream(String filePath, String content) throws IOException {
    BufferedOutputStream bos = null;
    try {
        bos = new BufferedOutputStream(new FileOutputStream(filePath));
        byte[] data = content.getBytes();
        bos.write(data);
        bos.flush(); // 刷新缓冲区
    } finally {
        if (bos != null) {
            bos.close();
        }
    }
}

// 使用BufferedReader读取文件
public static void readFileWithBufferedReader(String filePath) throws IOException {
    BufferedReader br = null;
    try {
        br = new BufferedReader(new FileReader(filePath));
        String line;
        while ((line = br.readLine()) != null) {
            // 按行处理读取的数据
            System.out.println(line);
        }
    } finally {
        if (br != null) {
            br.close();
        }
    }
}

// 使用BufferedWriter写入文件
public static void writeFileWithBufferedWriter(String filePath, List<String> lines) throws IOException {
    BufferedWriter bw = null;
    try {
        bw = new BufferedWriter(new FileWriter(filePath));
        for (String line : lines) {
            bw.write(line);
            bw.newLine(); // 写入换行符
        }
        bw.flush(); // 刷新缓冲区
    } finally {
        if (bw != null) {
            bw.close();
        }
    }
}

转换流的作用：字节流 ↔ 字符流

// 使用InputStreamReader读取指定编码的文件
public static void readFileWithEncoding(String filePath, String encoding) throws IOException {
    BufferedReader br = null;
    try {
        br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), encoding));
        String line;
        while ((line = br.readLine()) != null) {
            // 处理读取的数据
            System.out.println(line);
        }
    } finally {
        if (br != null) {
            br.close();
        }
    }
}

// 使用OutputStreamWriter写入指定编码的文件
public static void writeFileWithEncoding(String filePath, String content, String encoding) throws IOException {
    BufferedWriter bw = null;
    try {
        bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filePath), encoding));
        bw.write(content);
        bw.flush(); // 刷新缓冲区
    } finally {
        if (bw != null) {
            bw.close();
        }
    }
}

数据流的特点：可以直接读写基本数据类型和字符串，无需手动进行类型转换

// 使用DataInputStream读取基本数据类型
public static void readData(String filePath) throws IOException {
    DataInputStream dis = null;
    try {
        dis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));
        // 按写入顺序读取数据
        int intValue = dis.readInt();
        double doubleValue = dis.readDouble();
        boolean booleanValue = dis.readBoolean();
        String stringValue = dis.readUTF();
        
        // 处理读取的数据
        System.out.println("intValue: " + intValue);
        System.out.println("doubleValue: " + doubleValue);
        System.out.println("booleanValue: " + booleanValue);
        System.out.println("stringValue: " + stringValue);
    } finally {
        if (dis != null) {
            dis.close();
        }
    }
}

// 使用DataOutputStream写入基本数据类型
public static void writeData(String filePath) throws IOException {
    DataOutputStream dos = null;
    try {
        dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(filePath)));
        // 写入各种基本数据类型
        dos.writeInt(42);
        dos.writeDouble(3.14159);
        dos.writeBoolean(true);
        dos.writeUTF("Hello, Java IO!");
        
        dos.flush(); // 刷新缓冲区
    } finally {
        if (dos != null) {
            dos.close();
        }
    }
}

序列化：对象 → 字节序列
反序列化：字节序列 → 对象

// 定义一个可序列化的类
class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    private transient String password; // 不参与序列化
    
    // 构造方法、getter和setter方法
    // ...
}

// 使用ObjectOutputStream序列化对象
public static void serializeObject(String filePath, Object object) throws IOException {
    ObjectOutputStream oos = null;
    try {
        oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(filePath)));
        oos.writeObject(object);
        oos.flush(); // 刷新缓冲区
    } finally {
        if (oos != null) {
            oos.close();
        }
    }
}

// 使用ObjectInputStream反序列化对象
public static Object deserializeObject(String filePath) throws IOException, ClassNotFoundException {
    ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(filePath)));
        return ois.readObject();
    } finally {
        if (ois != null) {
            ois.close();
        }
    }
}

class Person implements Serializable {
    // ...
    
    private void writeObject(ObjectOutputStream out) throws IOException {
        // 调用默认的序列化方法
        out.defaultWriteObject();
        // 自定义序列化逻辑，如对敏感数据进行加密
        String encryptedPassword = encrypt(password);
        out.writeUTF(encryptedPassword);
    }
    
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // 调用默认的反序列化方法
        in.defaultReadObject();
        // 自定义反序列化逻辑，如对敏感数据进行解密
        String encryptedPassword = in.readUTF();
        this.password = decrypt(encryptedPassword);
    }
    
    private String encrypt(String input) {
        // 加密逻辑
        // ...
        return encrypted;
    }
    
    private String decrypt(String input) {
        // 解密逻辑
        // ...
        return decrypted;
    }
}

class Person implements Externalizable {
    private String name;
    private int age;
    private String password;
    
    // 必须提供无参构造方法
    public Person() {
    }
    
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // 完全自定义序列化过程
        out.writeUTF(name);
        out.writeInt(age);
        out.writeUTF(encrypt(password));
    }
    
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // 完全自定义反序列化过程
        this.name = in.readUTF();
        this.age = in.readInt();
        this.password = decrypt(in.readUTF());
    }
    
    // 其他方法
    // ...
}

随机访问文件的特点：可以任意位置读写，适合处理大型文件和需要随机访问的数据

// 以只读模式打开文件
RandomAccessFile rafRead = new RandomAccessFile("data.txt", "r");

// 以读写模式打开文件
RandomAccessFile rafReadWrite = new RandomAccessFile("data.txt", "rw");

// 读取文件的指定部分
public static byte[] readFilePart(String filePath, long position, int length) throws IOException {
    RandomAccessFile raf = null;
    try {
        raf = new RandomAccessFile(filePath, "r");
        // 跳转到指定位置
        raf.seek(position);
        // 读取指定长度的数据
        byte[] buffer = new byte[length];
        int bytesRead = raf.read(buffer);
        if (bytesRead < length) {
            // 如果实际读取的字节数小于请求的字节数，创建一个新的字节数组
            byte[] actualBuffer = new byte[bytesRead];
            System.arraycopy(buffer, 0, actualBuffer, 0, bytesRead);
            return actualBuffer;
        }
        return buffer;
    } finally {
        if (raf != null) {
            raf.close();
        }
    }
}

// 写入数据到文件的指定位置
public static void writeFilePart(String filePath, long position, byte[] data) throws IOException {
    RandomAccessFile raf = null;
    try {
        raf = new RandomAccessFile(filePath, "rw");
        // 跳转到指定位置
        raf.seek(position);
        // 写入数据
        raf.write(data);
    } finally {
        if (raf != null) {
            raf.close();
        }
    }
}

// 实现文件分割
public static void splitFile(String sourceFilePath, String targetDirPath, long chunkSize) throws IOException {
    RandomAccessFile raf = null;
    try {
        raf = new RandomAccessFile(sourceFilePath, "r");
        long fileLength = raf.length();
        int chunkCount = (int) Math.ceil((double) fileLength / chunkSize);
        
        for (int i = 0; i < chunkCount; i++) {
            long currentPosition = i * chunkSize;
            long currentChunkSize = Math.min(chunkSize, fileLength - currentPosition);
            
            String chunkFilePath = targetDirPath + "/chunk_" + i + ".part";
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(chunkFilePath);
                raf.seek(currentPosition);
                
                byte[] buffer = new byte[8192];
                long bytesWritten = 0;
                while (bytesWritten < currentChunkSize) {
                    int bytesRead = raf.read(buffer, 0, (int) Math.min(buffer.length, currentChunkSize - bytesWritten));
                    if (bytesRead == -1) {
                        break;
                    }
                    fos.write(buffer, 0, bytesRead);
                    bytesWritten += bytesRead;
                }
            } finally {
                if (fos != null) {
                    fos.close();
                }
            }
        }
    } finally {
        if (raf != null) {
            raf.close();
        }
    }
}

NIO的核心组件：通道（Channel）、缓冲区（Buffer）、选择器（Selector）

// 使用ByteBuffer读取数据
public static void readWithByteBuffer(String filePath) throws IOException {
    FileChannel fileChannel = null;
    try {
        fileChannel = new FileInputStream(filePath).getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(8192); // 分配8KB缓冲区
        
        while (fileChannel.read(buffer) != -1) {
            buffer.flip(); // 切换到读模式
            
            // 处理缓冲区中的数据
            byte[] data = new byte[buffer.remaining()];
            buffer.get(data);
            System.out.print(new String(data));
            
            buffer.clear(); // 清空缓冲区，准备下一次读取
        }
    } finally {
        if (fileChannel != null) {
            fileChannel.close();
        }
    }
}

// 使用ByteBuffer写入数据
public static void writeWithByteBuffer(String filePath, String content) throws IOException {
    FileChannel fileChannel = null;
    try {
        fileChannel = new FileOutputStream(filePath).getChannel();
        ByteBuffer buffer = ByteBuffer.allocate(8192); // 分配8KB缓冲区
        
        byte[] data = content.getBytes();
        buffer.put(data);
        buffer.flip(); // 切换到写模式
        
        fileChannel.write(buffer);
    } finally {
        if (fileChannel != null) {
            fileChannel.close();
        }
    }
}

// 使用FileChannel进行文件复制
public static void copyFileWithChannel(String sourceFilePath, String targetFilePath) throws IOException {
    FileChannel sourceChannel = null;
    FileChannel targetChannel = null;
    try {
        sourceChannel = new FileInputStream(sourceFilePath).getChannel();
        targetChannel = new FileOutputStream(targetFilePath).getChannel();
        
        // 直接传输数据，无需中间缓冲区
        targetChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
    } finally {
        if (sourceChannel != null) {
            sourceChannel.close();
        }
        if (targetChannel != null) {
            targetChannel.close();
        }
    }
}

// 使用Selector实现非阻塞IO
public static void startServer(int port) throws IOException {
    // 创建ServerSocketChannel并配置为非阻塞模式
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.configureBlocking(false);
    serverSocketChannel.socket().bind(new InetSocketAddress(port));
    
    // 创建Selector
    Selector selector = Selector.open();
    
    // 将ServerSocketChannel注册到Selector，关注连接事件
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    
    // 处理事件循环
    while (true) {
        // 阻塞等待事件发生，返回发生事件的通道数量
        int readyChannels = selector.select();
        
        if (readyChannels == 0) {
            continue;
        }
        
        // 获取所有发生事件的SelectionKey
        Set<SelectionKey> selectionKeys = selector.selectedKeys();
        Iterator<SelectionKey> iterator = selectionKeys.iterator();
        
        while (iterator.hasNext()) {
            SelectionKey key = iterator.next();
            iterator.remove(); // 移除已处理的SelectionKey
            
            if (key.isAcceptable()) {
                // 处理连接事件
                handleAccept(key);
            } else if (key.isReadable()) {
                // 处理可读事件
                handleRead(key);
            } else if (key.isWritable()) {
                // 处理可写事件
                handleWrite(key);
            }
        }
    }
}

private static void handleAccept(SelectionKey key) throws IOException {
    ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
    SocketChannel socketChannel = serverSocketChannel.accept();
    socketChannel.configureBlocking(false);
    // 注册到Selector，关注可读事件
    socketChannel.register(key.selector(), SelectionKey.OP_READ);
}

private static void handleRead(SelectionKey key) throws IOException {
    SocketChannel socketChannel = (SocketChannel) key.channel();
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    int bytesRead = socketChannel.read(buffer);
    
    if (bytesRead == -1) {
        // 连接关闭
        socketChannel.close();
        key.cancel();
        return;
    }
    
    buffer.flip();
    byte[] data = new byte[buffer.remaining()];
    buffer.get(data);
    String message = new String(data);
    System.out.println("Received: " + message);
    
    // 处理完数据后，注册可写事件，准备发送响应
    socketChannel.register(key.selector(), SelectionKey.OP_WRITE, message);
}

private static void handleWrite(SelectionKey key) throws IOException {
    SocketChannel socketChannel = (SocketChannel) key.channel();
    String message = (String) key.attachment();
    ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
    socketChannel.write(buffer);
    
    // 发送完响应后，重新注册可读事件
    socketChannel.register(key.selector(), SelectionKey.OP_READ);
}

// 使用缓冲流高效读取大文件
public static void processLargeFileWithBufferedStream(String inputFilePath, String outputFilePath) throws IOException {
    BufferedReader reader = null;
    BufferedWriter writer = null;
    try {
        // 使用较大的缓冲区（如64KB）
        reader = new BufferedReader(new FileReader(inputFilePath), 65536);
        writer = new BufferedWriter(new FileWriter(outputFilePath), 65536);
        
        String line;
        int lineCount = 0;
        while ((line = reader.readLine()) != null) {
            // 处理每一行数据
            String processedLine = processLine(line);
            writer.write(processedLine);
            writer.newLine();
            
            lineCount++;
            if (lineCount % 100000 == 0) {
                System.out.println("Processed " + lineCount + " lines");
            }
        }
    } finally {
        if (reader != null) {
            reader.close();
        }
        if (writer != null) {
            writer.close();
        }
    }
}

// 简单的数据处理函数
private static String processLine(String line) {
    // 根据实际需求实现数据处理逻辑
    // 示例：过滤、转换、提取信息等
    return line.toUpperCase(); // 示例：将文本转换为大写
}

// 使用NIO高效读写大文件
public static void processLargeFileWithNIO(String inputFilePath, String outputFilePath) throws IOException {
    FileChannel inChannel = null;
    FileChannel outChannel = null;
    try {
        inChannel = new FileInputStream(inputFilePath).getChannel();
        outChannel = new FileOutputStream(outputFilePath).getChannel();
        
        // 获取文件大小
        long fileSize = inChannel.size();
        
        // 内存映射文件
        MappedByteBuffer buffer = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, fileSize);
        
        // 处理映射的内存数据
        // 注意：这里的处理逻辑需要根据文件的实际格式进行调整
        // 以下代码仅作为示例，实际应用中可能需要更复杂的处理
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        String content = new String(data);
        
        // 简单的数据处理
        String processedContent = content.toUpperCase();
        
        // 写入处理后的数据
        ByteBuffer outBuffer = ByteBuffer.wrap(processedContent.getBytes());
        outChannel.write(outBuffer);
    } finally {
        if (inChannel != null) {
            inChannel.close();
        }
        if (outChannel != null) {
            outChannel.close();
        }
    }
}

// 使用多线程并行处理大文件
public static void processLargeFileWithMultithreading(String inputFilePath, String outputFilePath, int threadCount) throws IOException, InterruptedException {
    File inputFile = new File(inputFilePath);
    long fileSize = inputFile.length();
    
    // 计算每个线程处理的文件块大小
    long chunkSize = fileSize / threadCount;
    if (fileSize % threadCount != 0) {
        chunkSize++;
    }
    
    // 创建线程池
    ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
    CountDownLatch latch = new CountDownLatch(threadCount);
    
    // 创建临时文件，用于存储每个线程的处理结果
    List<File> tempFiles = new ArrayList<>();
    
    for (int i = 0; i < threadCount; i++) {
        final long startPosition = i * chunkSize;
        final long endPosition = Math.min((i + 1) * chunkSize, fileSize);
        final int threadId = i;
        
        executorService.submit(() -> {
            try {
                File tempFile = processFileChunk(inputFilePath, startPosition, endPosition, threadId);
                synchronized (tempFiles) {
                    tempFiles.add(tempFile);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                latch.countDown();
            }
        });
    }
    
    // 等待所有线程完成
    latch.await();
    
    // 合并临时文件
    mergeFiles(tempFiles, outputFilePath);
    
    // 删除临时文件
    for (File tempFile : tempFiles) {
        tempFile.delete();
    }
    
    // 关闭线程池
    executorService.shutdown();
}

// 处理文件的一个块
private static File processFileChunk(String inputFilePath, long startPosition, long endPosition, int threadId) throws IOException {
    RandomAccessFile raf = null;
    File tempFile = null;
    BufferedWriter writer = null;
    try {
        raf = new RandomAccessFile(inputFilePath, "r");
        raf.seek(startPosition);
        
        tempFile = File.createTempFile("chunk_", "_" + threadId);
        writer = new BufferedWriter(new FileWriter(tempFile));
        
        // 读取并处理文件块
        // 注意：这里需要处理行的完整性问题，确保不会在一行的中间断开
        // 以下代码仅作为简化示例
        String line;
        while (raf.getFilePointer() < endPosition && (line = raf.readLine()) != null) {
            String processedLine = processLine(line);
            writer.write(processedLine);
            writer.newLine();
        }
        
        return tempFile;
    } finally {
        if (raf != null) {
            raf.close();
        }
        if (writer != null) {
            writer.close();
        }
    }
}

// 合并多个文件
private static void mergeFiles(List<File> files, String outputFilePath) throws IOException {
    BufferedWriter writer = null;
    try {
        writer = new BufferedWriter(new FileWriter(outputFilePath));
        
        for (File file : files) {
            BufferedReader reader = null;
            try {
                reader = new BufferedReader(new FileReader(file));
                String line;
                while ((line = reader.readLine()) != null) {
                    writer.write(line);
                    writer.newLine();
                }
            } finally {
                if (reader != null) {
                    reader.close();
                }
            }
        }
    } finally {
        if (writer != null) {
            writer.close();
        }
    }
}

// 使用线程池并行读取多个文件
public static Map<String, String> parallelReadFiles(List<String> filePaths, int threadCount) throws InterruptedException, ExecutionException {
    // 创建线程池，线程数不宜过多，通常为CPU核心数或稍多
    ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
    
    // 存储每个文件的读取任务
    List<Callable<Map.Entry<String, String>>> tasks = new ArrayList<>();
    
    for (String filePath : filePaths) {
        final String path = filePath;
        tasks.add(() -> {
            String content = readFileContent(path);
            return new AbstractMap.SimpleEntry<>(path, content);
        });
    }
    
    // 提交所有任务并获取Future对象
    List<Future<Map.Entry<String, String>>> futures = executorService.invokeAll(tasks);
    
    // 收集所有任务的结果
    Map<String, String> results = new HashMap<>();
    for (Future<Map.Entry<String, String>> future : futures) {
        Map.Entry<String, String> entry = future.get();
        results.put(entry.getKey(), entry.getValue());
    }
    
    // 关闭线程池
    executorService.shutdown();
    
    return results;
}

// 读取文件内容的辅助方法
private static String readFileContent(String filePath) throws IOException {
    StringBuilder content = new StringBuilder();
    BufferedReader reader = null;
    try {
        reader = new BufferedReader(new FileReader(filePath));
        String line;
        while ((line = reader.readLine()) != null) {
            content.append(line);
            content.append(System.lineSeparator());
        }
        return content.toString();
    } finally {
        if (reader != null) {
            reader.close();
        }
    }
}

// 使用线程池并行写入多个文件
public static void parallelWriteFiles(Map<String, String> fileContents, int threadCount) throws InterruptedException, ExecutionException {
    ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
    
    List<Callable<Void>> tasks = new ArrayList<>();
    
    for (Map.Entry<String, String> entry : fileContents.entrySet()) {
        final String filePath = entry.getKey();
        final String content = entry.getValue();
        tasks.add(() -> {
            writeFileContent(filePath, content);
            return null;
        });
    }
    
    // 提交所有任务并等待完成
    List<Future<Void>> futures = executorService.invokeAll(tasks);
    
    // 检查是否有异常发生
    for (Future<Void> future : futures) {
        future.get(); // 如果任务执行过程中发生异常，这里会抛出
    }
    
    executorService.shutdown();
}

// 写入文件内容的辅助方法
private static void writeFileContent(String filePath, String content) throws IOException {
    BufferedWriter writer = null;
    try {
        writer = new BufferedWriter(new FileWriter(filePath));
        writer.write(content);
        writer.flush();
    } finally {
        if (writer != null) {
            writer.close();
        }
    }
}

// 多线程文件处理与进度监控
public static void processFilesWithProgressMonitor(List<String> filePaths, int threadCount) {
    ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
    CountDownLatch latch = new CountDownLatch(filePaths.size());
    
    // 使用线程安全的计数器记录已完成的任务数
    AtomicInteger completedTasks = new AtomicInteger(0);
    int totalTasks = filePaths.size();
    
    for (String filePath : filePaths) {
        final String path = filePath;
        executorService.submit(() -> {
            try {
                // 处理文件
                processFile(path);
                
                // 更新进度
                int completed = completedTasks.incrementAndGet();
                double progressPercentage = (double) completed / totalTasks * 100;
                System.out.printf("Progress: %.2f%% (%d/%d files processed)\n", 
                        progressPercentage, completed, totalTasks);
            } catch (IOException e) {
                System.err.println("Error processing file " + path + ": " + e.getMessage());
            } finally {
                latch.countDown();
            }
        });
    }
    
    // 创建一个单独的线程监控整体进度
    Thread monitorThread = new Thread(() -> {
        try {
            while (latch.getCount() > 0) {
                Thread.sleep(1000); // 每秒更新一次进度
                int completed = completedTasks.get();
                double progressPercentage = (double) completed / totalTasks * 100;
                System.out.printf("Overall Progress: %.2f%%\n", progressPercentage);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    
    monitorThread.start();
    
    try {
        // 等待所有任务完成
        latch.await();
        System.out.println("All files processed successfully!");
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        // 关闭线程池
        executorService.shutdown();
        // 中断监控线程
        monitorThread.interrupt();
    }
}

// 文件处理的辅助方法
private static void processFile(String filePath) throws IOException {
    // 根据实际需求实现文件处理逻辑
    // 示例：简单地读取文件内容并做一些处理
    String content = readFileContent(filePath);
    // 模拟处理时间
    try {
        Thread.sleep(100);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

// TCP服务器实现
public class TCPServer {
    private final int port;
    private final ExecutorService threadPool;
    
    public TCPServer(int port, int threadPoolSize) {
        this.port = port;
        this.threadPool = Executors.newFixedThreadPool(threadPoolSize);
    }
    
    public void start() throws IOException {
        ServerSocket serverSocket = new ServerSocket(port);
        System.out.println("TCP Server started on port " + port);
        
        try {
            while (true) {
                // 接受客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress().getHostAddress());
                
                // 为每个客户端创建一个新的线程处理请求
                threadPool.submit(() -> handleClient(clientSocket));
            }
        } finally {
            serverSocket.close();
            threadPool.shutdown();
        }
    }
    
    private void handleClient(Socket clientSocket) {
        try (
            // 使用try-with-resources自动关闭资源
            BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            PrintWriter writer = new PrintWriter(clientSocket.getOutputStream(), true);
        ) {
            String message;
            // 读取客户端发送的消息
            while ((message = reader.readLine()) != null) {
                System.out.println("Received from client " + clientSocket.getInetAddress().getHostAddress() + ": " + message);
                
                // 处理消息并发送响应
                String response = processMessage(message);
                writer.println(response);
                System.out.println("Sent to client: " + response);
                
                // 如果客户端发送了"BYE"，则关闭连接
                if ("BYE".equalsIgnoreCase(message.trim())) {
                    break;
                }
            }
        } catch (IOException e) {
            System.err.println("Error handling client: " + e.getMessage());
        } finally {
            try {
                clientSocket.close();
                System.out.println("Client disconnected: " + clientSocket.getInetAddress().getHostAddress());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    private String processMessage(String message) {
        // 根据实际需求实现消息处理逻辑
        // 示例：简单地将消息转换为大写并添加前缀
        return "SERVER RESPONSE: " + message.toUpperCase();
    }
    
    public static void main(String[] args) {
        try {
            TCPServer server = new TCPServer(8080, 10);
            server.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// TCP客户端实现
public class TCPClient {
    private final String serverAddress;
    private final int serverPort;
    
    public TCPClient(String serverAddress, int serverPort) {
        this.serverAddress = serverAddress;
        this.serverPort = serverPort;
    }
    
    public void start() throws IOException {
        try (
            Socket socket = new Socket(serverAddress, serverPort);
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
            BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
        ) {
            System.out.println("Connected to server " + serverAddress + ":" + serverPort);
            System.out.println("Type messages to send (type 'BYE' to disconnect)");
            
            String userInput;
            // 从控制台读取用户输入并发送到服务器
            while ((userInput = consoleReader.readLine()) != null) {
                writer.println(userInput);
                
                // 读取服务器响应
                String response = reader.readLine();
                System.out.println("Server response: " + response);
                
                // 如果用户输入了"BYE"，则退出循环
                if ("BYE".equalsIgnoreCase(userInput.trim())) {
                    break;
                }
            }
        } catch (IOException e) {
            System.err.println("Error communicating with server: " + e.getMessage());
            throw e;
        }
    }
    
    public static void main(String[] args) {
        try {
            TCPClient client = new TCPClient("localhost", 8080);
            client.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// UDP服务器实现
public class UDPServer {
    private final int port;
    private DatagramSocket socket;
    private boolean running;
    
    public UDPServer(int port) {
        this.port = port;
    }
    
    public void start() throws IOException {
        socket = new DatagramSocket(port);
        running = true;
        System.out.println("UDP Server started on port " + port);
        
        byte[] buffer = new byte[1024];
        
        try {
            while (running) {
                // 创建数据报包以接收数据
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
                // 接收客户端发送的数据
                socket.receive(packet);
                
                // 获取客户端信息
                InetAddress clientAddress = packet.getAddress();
                int clientPort = packet.getPort();
                
                // 解析接收到的数据
                String receivedData = new String(packet.getData(), 0, packet.getLength());
                System.out.println("Received from client " + clientAddress.getHostAddress() + ":" + receivedData);
                
                // 处理数据并准备响应
                String response = "Echo: " + receivedData;
                byte[] responseData = response.getBytes();
                
                // 创建响应数据报包
                DatagramPacket responsePacket = new DatagramPacket(
                        responseData, responseData.length,
                        clientAddress, clientPort);
                
                // 发送响应
                socket.send(responsePacket);
                System.out.println("Sent response to client: " + response);
            }
        } catch (IOException e) {
            if (running) {
                e.printStackTrace();
            }
        } finally {
            stop();
        }
    }
    
    public void stop() {
        running = false;
        if (socket != null && !socket.isClosed()) {
            socket.close();
            System.out.println("UDP Server stopped");
        }
    }
    
    public static void main(String[] args) {
        final int PORT = 8080;
        UDPServer server = new UDPServer(PORT);
        
        // 创建并启动服务器线程
        Thread serverThread = new Thread(() -> {
            try {
                server.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        serverThread.start();
        
        // 添加关闭钩子，确保服务器能够优雅关闭
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("Shutting down server...");
            server.stop();
            try {
                serverThread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));
    }
}

// 使用直接缓冲区的示例
ByteBuffer directBuffer = ByteBuffer.allocateDirect(8192);

// 使用try-with-resources确保资源关闭
try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
    // 读取文件内容
    String line;
    while ((line = reader.readLine()) != null) {
        // 处理每一行
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 显式指定字符编码
try (BufferedReader reader = new BufferedReader(
        new InputStreamReader(new FileInputStream(filePath), StandardCharsets.UTF_8))) {
    // 读取文件内容
}

// 安全读取数据到缓冲区
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = inputStream.read(buffer)) != -1) {
    // 只处理实际读取的字节数
    processData(buffer, 0, bytesRead);
}

try {
    // IO操作
} catch (FileNotFoundException e) {
    System.err.println("File not found: " + e.getMessage());
} catch (IOException e) {
    System.err.println("IO error: " + e.getMessage());
    e.printStackTrace();
}

// 使用内存映射文件读取数据
public static void readWithMemoryMappedFile(String filePath) throws IOException {
    FileChannel channel = null;
    try {
        channel = new RandomAccessFile(filePath, "r").getChannel();
        long fileSize = channel.size();
        
        // 创建内存映射
        MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, fileSize);
        
        // 处理数据
        while (buffer.hasRemaining()) {
            // 读取数据
            byte b = buffer.get();
            // 处理数据
        }
    } finally {
        if (channel != null) {
            channel.close();
        }
    }
}

// 使用零拷贝技术复制文件
public static void copyWithZeroCopy(String sourceFilePath, String targetFilePath) throws IOException {
    FileChannel sourceChannel = null;
    FileChannel targetChannel = null;
    try {
        sourceChannel = new FileInputStream(sourceFilePath).getChannel();
        targetChannel = new FileOutputStream(targetFilePath).getChannel();
        
        // 使用transferTo方法实现零拷贝
        long position = 0;
        long remaining = sourceChannel.size();
        while (remaining > 0) {
            long transferred = sourceChannel.transferTo(position, remaining, targetChannel);
            position += transferred;
            remaining -= transferred;
        }
    } finally {
        if (sourceChannel != null) {
            sourceChannel.close();
        }
        if (targetChannel != null) {
            targetChannel.close();
        }
    }
}

// 使用NIO.2的Files类操作文件
public static void useNIO2(String filePath) throws IOException {
    // 读取全部文件内容
    byte[] content = Files.readAllBytes(Paths.get(filePath));
    
    // 按行读取文件内容
    List<String> lines = Files.readAllLines(Paths.get(filePath), StandardCharsets.UTF_8);
    
    // 写入文件
    Files.write(Paths.get("output.txt"), content);
    
    // 创建目录
    Files.createDirectories(Paths.get("new/directory"));
    
    // 复制文件
    Files.copy(Paths.get(filePath), Paths.get("copy.txt"), StandardCopyOption.REPLACE_EXISTING);
    
    // 移动文件
    Files.move(Paths.get(filePath), Paths.get("moved.txt"), StandardCopyOption.REPLACE_EXISTING);
    
    // 删除文件
    Files.deleteIfExists(Paths.get(filePath));
}