import java.io.*;

public class FileCopyBasic {
    public static void main(String[] args) {
        File src = new File("/tmp/source.bin");
        File dst = new File("/tmp/target.bin");
        // try-with-resources：无论是否异常，in/out 都会被自动关闭（实现 AutoCloseable 即可）
        try (InputStream in = new FileInputStream(src);
             OutputStream out = new FileOutputStream(dst)) {
            byte[] buf = new byte[8192];          // 8KB 缓冲数组
            int len;                              // 每次实际读到的字节数
            while ((len = in.read(buf)) != -1) {  // -1 代表流结束；务必用 len 而非 buf.length
                out.write(buf, 0, len);           // 只写出实际读到的部分，最后一次通常不满
            }
            out.flush();                          // 刷出用户缓冲区（close 也会 flush，显式写更清晰）
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;

public class BufferedCopy {
    // 第二个参数是缓冲区大小；不传则默认 8192
    private static final int BUF_SIZE = 64 * 1024; // 64KB：与常见磁盘块/页大小成整数倍

    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        // 处理流包裹节点流，只声明最外层即可
        try (BufferedInputStream bis =
                     new BufferedInputStream(new FileInputStream("/tmp/big.zip"), BUF_SIZE);
             BufferedOutputStream bos =
                     new BufferedOutputStream(new FileOutputStream("/tmp/big-copy.zip"), BUF_SIZE)) {
            byte[] buf = new byte[BUF_SIZE];
            int len;
            while ((len = bis.read(buf)) != -1) {
                bos.write(buf, 0, len);
            }
        }
        System.out.println("耗时: " + (System.currentTimeMillis() - start) + " ms");
    }
}

import java.io.*;
import java.nio.charset.StandardCharsets;

public class CharsetDemo {
    public static void main(String[] args) throws IOException {
        String text = "你好，Java IO！";
        File f = new File("/tmp/utf8.txt");

        // 正确姿势：字节流 + 显式指定 UTF-8 的桥接流，行为与平台无关
        try (Writer w = new BufferedWriter(
                new OutputStreamWriter(new FileOutputStream(f), StandardCharsets.UTF_8))) {
            w.write(text);
        }

        // 等价的读取方式
        try (BufferedReader r = new BufferedReader(
                new InputStreamReader(new FileInputStream(f), StandardCharsets.UTF_8))) {
            System.out.println(r.readLine());
        }
    }
}

import java.nio.*;
import java.nio.charset.*;

public class EncodingDetect {
    public static void main(String[] args) {
        byte[] data = {(byte) 0xE4, (byte) 0xBD, (byte) 0xA0}; // "你" 的 UTF-8 字节
        // REPORT 模式：遇到非法字节序列抛异常，而不是偷偷替换成 U+FFFD
        CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder()
                .onMalformedInput(CodingErrorAction.REPORT)
                .onUnmappableCharacter(CodingErrorAction.REPORT);
        try {
            CharBuffer cb = decoder.decode(ByteBuffer.wrap(data));
            System.out.println("UTF-8 解码成功: " + cb.toString());
        } catch (CharacterCodingException e) {
            System.out.println("不是合法的 UTF-8，可能是 GBK 或其它编码");
        }
    }
}

import java.io.*;

public class DataStreamDemo {
    public static void main(String[] args) throws IOException {
        File f = new File("/tmp/data.bin");
        // 写入：注意用 Buffered 包裹，否则每个 writeInt 都是一次系统调用
        try (DataOutputStream dos = new DataOutputStream(
                new BufferedOutputStream(new FileOutputStream(f)))) {
            dos.writeInt(2026);          // 4 字节
            dos.writeLong(123456789L);   // 8 字节
            dos.writeDouble(3.14159);    // 8 字节
            dos.writeBoolean(true);      // 1 字节
            dos.writeUTF("张三");         // 2 字节长度前缀 + 改良 UTF-8 字节
        }
        // 读取：顺序必须与写入完全一致，否则数据错位
        try (DataInputStream dis = new DataInputStream(
                new BufferedInputStream(new FileInputStream(f)))) {
            System.out.println(dis.readInt());
            System.out.println(dis.readLong());
            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());
            System.out.println(dis.readUTF());
        }
    }
}

import java.io.*;

class User implements Serializable {
    // 显式声明版本号：类结构变化时保证兼容性，第五章详述
    private static final long serialVersionUID = 1L;
    private String name;
    private transient String password; // transient：不参与序列化
    private int age;

    public User(String name, String password, int age) {
        this.name = name; this.password = password; this.age = age;
    }
    @Override public String toString() {
        return "User{name='" + name + "', password='" + password + "', age=" + age + "}";
    }
}

public class SerializeDemo {
    public static void main(String[] args) throws Exception {
        File f = new File("/tmp/user.obj");
        try (ObjectOutputStream oos =
                     new ObjectOutputStream(new FileOutputStream(f))) {
            oos.writeObject(new User("张三", "secret123", 28));
        }
        try (ObjectInputStream ois =
                     new ObjectInputStream(new FileInputStream(f))) {
            User u = (User) ois.readObject();
            System.out.println(u); // password 为 null，因为被 transient 修饰
        }
    }
}

import java.io.*;
import java.nio.charset.StandardCharsets;

public class PipedDemo {
    public static void main(String[] args) throws Exception {
        PipedInputStream pin = new PipedInputStream();
        PipedOutputStream pout = new PipedOutputStream();
        pout.connect(pin); // 或用 new PipedOutputStream(pin)

        Thread producer = new Thread(() -> {
            try (Writer w = new OutputStreamWriter(pout, StandardCharsets.UTF_8)) {
                for (int i = 1; i <= 5; i++) {
                    w.write("消息-" + i + "\n");
                    w.flush();                 // 必须 flush，否则数据留在缓冲区
                    Thread.sleep(200);
                }
            } catch (Exception e) { e.printStackTrace(); }
        }, "producer");

        Thread consumer = new Thread(() -> {
            try (BufferedReader r = new BufferedReader(
                    new InputStreamReader(pin, StandardCharsets.UTF_8))) {
                String line;
                while ((line = r.readLine()) != null) { // 写端关闭后 readLine 返回 null
                    System.out.println("收到: " + line);
                }
            } catch (Exception e) { e.printStackTrace(); }
        }, "consumer");

        producer.start();
        consumer.start();
    }
}

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.stream.Stream;

public class WalkDemo {
    public static void main(String[] args) throws IOException {
        Path root = Paths.get("/tmp/project");

        // 1) Stream 是惰性的，必须 close；不跟随符号链接防止死循环
        try (Stream<Path> paths = Files.walk(root, 5, FileVisitOption.FOLLOW_LINKS)) {
            paths.filter(Files::isRegularFile)
                 .filter(p -> p.toString().endsWith(".java"))
                 .forEach(p -> System.out.println(p.getFileName()));
        }

        // 2) 统计目录总大小：BasicFileAttributes 一次 stat 拿到所有元数据
        try (Stream<Path> paths = Files.walk(root)) {
            long total = paths.filter(Files::isRegularFile)
                    .mapToLong(p -> {
                        try { return Files.readAttributes(p, BasicFileAttributes.class).size(); }
                        catch (IOException e) { return 0L; }
                    }).sum();
            System.out.println("总大小: " + total + " bytes");
        }

        // 3) 与 File 互转：file.toPath() / path.toFile()
        File old = new File("/tmp/a.txt");
        Path p = old.toPath();
        System.out.println(p.toFile().equals(old));
    }
}

import java.nio.file.*;

public class WatchDemo {
    public static void main(String[] args) throws Exception {
        // 每个 WatchService 背后通常是一个 OS 原生线程（macOS 走 kqueue，Linux 走 inotify）
        WatchService ws = FileSystems.getDefault().newWatchService();
        Path dir = Paths.get("/tmp/watch");
        // register 返回 WatchKey；三种标准事件
        dir.register(ws,
                StandardWatchEventKinds.ENTRY_CREATE,
                StandardWatchEventKinds.ENTRY_DELETE,
                StandardWatchEventKinds.ENTRY_MODIFY);

        System.out.println("监听中: " + dir);
        while (true) {
            WatchKey key = ws.take();               // 阻塞等待事件，也可用 poll() 非阻塞
            for (WatchEvent<?> event : key.pollEvents()) {
                WatchEvent.Kind<?> kind = event.kind();
                if (kind == StandardWatchEventKinds.OVERFLOW) continue; // 事件溢出，需全量重新扫描
                Path file = ((WatchEvent<Path>) event).context();
                System.out.println(kind.name() + " -> " + file);
            }
            // 必须 reset，否则 key 失效后不会再收到事件
            if (!key.reset()) { break; }
        }
    }
}

import java.io.*;

class Account implements Serializable {
    private static final long serialVersionUID = 1L;
    private String user;
    private transient String password; // 不直接序列化明文

    public Account(String user, String password) {
        this.user = user; this.password = password;
    }
    // JVM 通过反射回调；签名必须严格一致（private void + 参数类型）
    private void writeObject(ObjectOutputStream oos) throws IOException {
        oos.defaultWriteObject();                 // 先写非 transient 字段
        oos.writeUTF(Base64.getEncoder().encodeToString(password.getBytes())); // 自定义加密写
    }
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();                  // 读非 transient 字段
        this.password = new String(Base64.getDecoder().decode(ois.readUTF())); // 对称还原
    }
    @Override public String toString() { return user + "/" + password; }
}

import java.io.*;

class Singleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static final Singleton INSTANCE = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() { return INSTANCE; }

    // 反序列化时返回已有实例，新创建的对象被丢弃（可被 GC）
    private Object readResolve() { return INSTANCE; }
}

public class SingletonTest {
    public static void main(String[] args) throws Exception {
        Singleton s = Singleton.getInstance();
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        new ObjectOutputStream(bos).writeObject(s);
        Object o = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray())).readObject();
        System.out.println("同一实例? " + (o == s)); // true
    }
}

import java.io.*;

public class SafeDeserialize {
    public static void main(String[] args) throws Exception {
        ByteArrayInputStream bis = new ByteArrayInputStream(args[0].getBytes());
        try (ObjectInputStream ois = new ObjectInputStream(bis)) {
            // 白名单：只允许本包下的 User/Order，限制数组长度、引用数、字节数、递归深度
            ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(
                    "com.example.User;com.example.Order;!*;" +
                    "maxarray=1000;maxrefs=500;maxbytes=8192;maxdepth=5");
            ois.setObjectInputFilter(filter);
            Object obj = ois.readObject(); // 非法类会在反序列化前被拒绝，抛 InvalidClassException
            System.out.println(obj);
        }
    }
}

import java.nio.ByteBuffer;

public class BufferStateMachine {
    public static void main(String[] args) {
        ByteBuffer buf = ByteBuffer.allocate(10); // capacity=10, position=0, limit=10（写模式）
        print("初始化", buf);

        buf.put((byte) 'a').put((byte) 'b').put((byte) 'c'); // 写 3 字节，position=3
        print("写入3字节", buf);

        buf.flip(); // 写模式 -> 读模式：limit=position(3), position=0
        print("flip后", buf);

        System.out.println("remaining=" + buf.remaining()); // 3
        while (buf.hasRemaining()) {
            System.out.print((char) buf.get());  // 依次读 a b c，position 递增到 3
        }
        System.out.println();
        print("读完", buf);

        buf.rewind(); // position=0，limit 不变，可重复读
        print("rewind后", buf);
    }
    static void print(String tag, ByteBuffer b) {
        System.out.printf("%-12s capacity=%d position=%d limit=%d%n",
                tag, b.capacity(), b.position(), b.limit());
    }
}

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.*;

public class ChannelDemo {
    public static void main(String[] args) throws IOException {
        // transferTo：零拷贝复制文件（第八章详述），底层走 sendfile
        try (FileChannel src = FileChannel.open(Paths.get("/tmp/big.zip"), StandardOpenOption.READ);
             FileChannel dst = FileChannel.open(Paths.get("/tmp/big-copy.zip"),
                     StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
            long pos = 0, size = src.size();
            // 单次 transfer 有上限（Linux 约 2GB），必须循环
            while (pos < size) {
                long transferred = src.transferTo(pos, size - pos, dst);
                if (transferred <= 0) break; // 防御性：某些系统上返回 0
                pos += transferred;
            }
            dst.force(true); // 强制把数据与元数据刷到磁盘（fsync），类似数据库的 WAL
        }

        // 分散读取 Scatter：一次系统调用把数据填进多个 Buffer（适合定长协议头+变长体）
        try (FileChannel ch = FileChannel.open(Paths.get("/tmp/data.bin"), StandardOpenOption.READ)) {
            ByteBuffer header = ByteBuffer.allocate(8);   // 前 8 字节当协议头
            ByteBuffer body   = ByteBuffer.allocate(1024); // 其余当消息体
            ch.read(new ByteBuffer[]{header, body});       // 按顺序自动填充，无需手动切分
            header.flip();
            System.out.println("header 读到了 " + header.remaining() + " 字节");
        }

        // 聚集写入 Gather：多个 Buffer 合并成一次系统调用写出，减少 syscall 次数
        try (FileChannel ch = FileChannel.open(Paths.get("/tmp/gather.bin"),
                StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
            ByteBuffer a = ByteBuffer.wrap("HEAD".getBytes());
            ByteBuffer b = ByteBuffer.wrap("BODY".getBytes());
            ch.write(new ByteBuffer[]{a, b});
        }
    }
}

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class NioEchoServer {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();                 // 底层 epoll 实例
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress(9000));
        ssc.configureBlocking(false);                        // 必须非阻塞才能注册到 Selector
        ssc.register(selector, SelectionKey.OP_ACCEPT);      // 只关心连接事件
        System.out.println("Echo 服务器启动，端口 9000");

        while (true) {
            selector.select();                               // 阻塞直到有事件就绪（可传超时）
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey key = it.next();
                it.remove();                                 // 必须手动移除，否则下次重复处理
                try {
                    if (key.isAcceptable()) {
                        // 接受新连接，并注册读事件
                        SocketChannel sc = ((ServerSocketChannel) key.channel()).accept();
                        sc.configureBlocking(false);
                        sc.register(selector, SelectionKey.OP_READ,
                                ByteBuffer.allocate(1024));  // 每个连接附一个专属 Buffer
                        System.out.println("新连接: " + sc.getRemoteAddress());
                    } else if (key.isReadable()) {
                        SocketChannel sc = (SocketChannel) key.channel();
                        ByteBuffer buf = (ByteBuffer) key.attachment();
                        int n = sc.read(buf);
                        if (n == -1) {                       // 对端正常关闭
                            key.cancel();
                            sc.close();
                            System.out.println("连接关闭");
                            continue;
                        }
                        if (n > 0) {
                            buf.flip();                      // 切读模式：limit=position, position=0
                            sc.write(buf);                   // 回声写回（可能写不完，简化处理）
                            buf.compact();                   // 保留未写完的字节，切回写模式
                        }
                    }
                } catch (IOException e) {
                    key.cancel();                            // 异常连接必须取消注册并关闭
                    key.channel().close();
                }
            }
        }
    }
}

import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.*;

public class MappedBigFile {
    // 分段映射处理 10GB 超大文件：每段 1GB
    private static final long SEGMENT = 1024L * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        Path path = Paths.get("/tmp/huge.bin");
        try (FileChannel ch = FileChannel.open(path, StandardOpenOption.READ,
                StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
            long fileSize = 10L * 1024 * 1024 * 1024; // 10GB
            for (long offset = 0; offset < fileSize; offset += SEGMENT) {
                long size = Math.min(SEGMENT, fileSize - offset);
                // map 的 position/size 是 long，但返回的 Buffer 索引是 int，故单段不能超 2GB
                MappedByteBuffer map = ch.map(FileChannel.MapMode.READ_WRITE, offset, size);
                // 直接按内存访问，无系统调用；写操作由 OS 异步回写
                for (int i = 0; i < 8; i++) {
                    map.put(i, (byte) 'A');
                }
                map.force(); // 强制回写（相当于 msync），非必须；不调则由 OS 择机刷盘
                // MappedByteBuffer 的生命周期跟随映射，JDK 9+ 可用 Unsafe.invokeCleaner 主动释放
            }
        }
    }
}