I/O, NIO, and the Path API

InputStream (abstract)
├── FileInputStream        — reads bytes from a file
├── ByteArrayInputStream   — reads from a byte[] in memory
├── BufferedInputStream    — wraps another InputStream with buffering
├── DataInputStream        — reads primitive types (int, long, double, etc.)
├── ObjectInputStream      — deserializes Java objects
├── FilterInputStream      — base class for decorator streams
└── PipedInputStream       — reads from a PipedOutputStream (inter-thread)

OutputStream (abstract)
├── FileOutputStream       — writes bytes to a file
├── ByteArrayOutputStream  — writes to a byte[] in memory
├── BufferedOutputStream   — wraps another OutputStream with buffering
├── DataOutputStream       — writes primitive types
├── ObjectOutputStream     — serializes Java objects
├── FilterOutputStream     — base class for decorator streams
└── PipedOutputStream      — writes to a PipedInputStream (inter-thread)

try (FileInputStream fis = new FileInputStream("data.bin")) {
    byte[] buffer = new byte[8192];
    int bytesRead;
    while ((bytesRead = fis.read(buffer)) != -1) {
        // process buffer[0..bytesRead-1]
    }
}

try (DataInputStream dis = new DataInputStream(
        new BufferedInputStream(
            new FileInputStream("records.dat")))) {
    int count = dis.readInt();
    for (int i = 0; i < count; i++) {
        String name = dis.readUTF();
        double value = dis.readDouble();
    }
}

Reader (abstract)
├── InputStreamReader  — bridges InputStream → Reader (charset conversion)
├── FileReader          — convenience: InputStreamReader wrapping FileInputStream
├── BufferedReader      — adds readLine() and buffering
├── StringReader        — reads from a String in memory
├── CharArrayReader     — reads from a char[] in memory
├── PipedReader         — reads from a PipedWriter
└── FilterReader        — base class for decorator readers

Writer (abstract)
├── OutputStreamWriter  — bridges Writer → OutputStream (charset conversion)
├── FileWriter          — convenience: OutputStreamWriter wrapping FileOutputStream
├── BufferedWriter      — adds newLine() and buffering
├── StringWriter        — writes to a StringBuffer in memory
├── CharArrayWriter     — writes to a char[] in memory
├── PipedWriter         — writes to a PipedReader
└── FilterWriter        — base class for decorator writers

// Pre-JDK 11
try (BufferedReader br = new BufferedReader(
        new InputStreamReader(new FileInputStream("log.txt"), StandardCharsets.UTF_8))) {
    String line;
    while ((line = br.readLine()) != null) {
        // process line
    }
}

// JDK 11+
try (BufferedReader br = new BufferedReader(
        new FileReader("log.txt", StandardCharsets.UTF_8))) {
    String line;
    while ((line = br.readLine()) != null) {
        // process line
    }
}

// Correct: single buffered layer
try (var in = new BufferedInputStream(new FileInputStream("large.bin"));
     var out = new BufferedOutputStream(new FileOutputStream("copy.bin"))) {
    byte[] buf = new byte[8192];
    int n;
    while ((n = in.read(buf)) != -1) {
        out.write(buf, 0, n);
    }
}

// Reading a text file line by line (the most common pattern)
try (BufferedReader br = new BufferedReader(
        new FileReader("input.txt", StandardCharsets.UTF_8))) {
    br.lines()
      .filter(line -> !line.isBlank())
      .map(String::strip)
      .forEach(System.out::println);
}

// Writing a text file
try (BufferedWriter bw = new BufferedWriter(
        new FileWriter("output.txt", StandardCharsets.UTF_8))) {
    for (String line : data) {
        bw.write(line);
        bw.newLine();
    }
}

// Copying a binary file
try (InputStream in = new BufferedInputStream(new FileInputStream(src));
     OutputStream out = new BufferedOutputStream(new FileOutputStream(dst))) {
    in.transferTo(out);  // JDK 9
}

public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    private final String name;
    private final int age;
    private transient String password;  // not serialized

    // constructor, getters...
}

public class Config implements Externalizable {
    private String host;
    private int port;

    // zero-arg constructor required for deserialization
    public Config() {}

    public Config(String host, int port) {
        this.host = host;
        this.port = port;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(host);
        out.writeInt(port);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.host = in.readUTF();
        this.port = in.readInt();
    }
}

// Old way (java.io.File)
File file = new File("/tmp/data/input.txt");
boolean exists = file.exists();  // no exception declared, but may throw SecurityException

// New way (NIO.2)
Path path = Path.of("/tmp/data/input.txt");
boolean exists = Files.exists(path);  // clear API boundary

Path p1 = Path.of("/home/user/docs");
Path p2 = Path.of("report.txt");

// resolve: joins two paths (if p2 is absolute, returns p2)
Path resolved = p1.resolve(p2);  // /home/user/docs/report.txt

// resolveSibling: replaces the last component
Path sibling = p1.resolveSibling("backup");  // /home/user/backup

// normalize: removes . and .. where possible
Path messy = Path.of("/a/b/../c/./d");
Path clean = messy.normalize();  // /a/c/d

// relativize: computes the relative path between two paths
Path base = Path.of("/home/user");
Path target = Path.of("/home/user/docs/report.txt");
Path relative = base.relativize(target);  // docs/report.txt

// subpath: extracts a portion of the path
Path full = Path.of("/a/b/c/d");
Path sub = full.subpath(1, 3);  // b/c (0-indexed, exclusive end)

// getParent, getFileName, getRoot
Path p = Path.of("/home/user/docs/report.txt");
p.getRoot();       // /
p.getParent();     // /home/user/docs
p.getFileName();   // report.txt

// Read entire file as a string (JDK 11)
String content = Files.readString(Path.of("config.json"));

// Read all lines into a List<String>
List<String> lines = Files.readAllLines(Path.of("data.csv"), StandardCharsets.UTF_8);

// Lazy stream of lines (does not load entire file into memory)
try (Stream<String> stream = Files.lines(Path.of("huge.log"), StandardCharsets.UTF_8)) {
    stream.filter(line -> line.contains("ERROR"))
          .limit(100)
          .forEach(System.out::println);
}

// Write a string to a file
Files.writeString(Path.of("output.txt"), "hello, world", StandardCharsets.UTF_8,
        StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);

// Write lines
List<String> data = List.of("line1", "line2", "line3");
Files.write(Path.of("output.txt"), data, StandardCharsets.UTF_8);

// Copy a file
Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES);

// Copy a directory (non-recursive — only copies the directory entry)
Files.copy(srcDir, dstDir);

// Move (rename) a file
Files.move(src, dst, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);

// Delete a file (throws NoSuchFileException if not found)
Files.delete(path);

// Delete if exists (returns false if not found, does not throw)
boolean deleted = Files.deleteIfExists(path);

// Delete a non-empty directory
Files.walkFileTree(dir, new SimpleFileVisitor<>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
        Files.delete(file);
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult postVisitDirectory(Path d, IOException exc) throws IOException {
        Files.delete(d);
        return FileVisitResult.CONTINUE;
    }
});

// Read basic attributes in a single system call
BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
attrs.isRegularFile();
attrs.isDirectory();
attrs.isSymbolicLink();
attrs.size();
attrs.lastModifiedTime();
attrs.creationTime();

// Read POSIX attributes (Unix only)
PosixFileAttributes posixAttrs = Files.readAttributes(path, PosixFileAttributes.class);
Set<PosixFilePermission> perms = posixAttrs.permissions();

// Check and set permissions
boolean canRead = Files.isReadable(path);
boolean canWrite = Files.isWritable(path);
boolean canExecute = Files.isExecutable(path);

// Set permissions
Files.setPosixFilePermissions(path,
    PosixFilePermissions.fromString("rw-r--r--"));

// DOS attributes (Windows)
DosFileAttributes dosAttrs = Files.readAttributes(path, DosFileAttributes.class);
dosAttrs.isReadOnly();
dosAttrs.isHidden();
dosAttrs.isSystem();

try (WatchService watcher = FileSystems.getDefault().newWatchService()) {
    Path dir = Path.of("/home/user/watched");
    dir.register(watcher,
        StandardWatchEventKinds.ENTRY_CREATE,
        StandardWatchEventKinds.ENTRY_DELETE,
        StandardWatchEventKinds.ENTRY_MODIFY);

    WatchKey key;
    while ((key = watcher.take()) != null) {
        for (WatchEvent<?> event : key.pollEvents()) {
            WatchEvent.Kind<?> kind = event.kind();

            if (kind == StandardWatchEventKinds.OVERFLOW) {
                continue;
            }

            Path changedFile = dir.resolve((Path) event.context());
            System.out.printf("%s: %s%n", kind, changedFile);
        }

        if (!key.reset()) {
            break;  // directory no longer accessible
        }
    }
}

// Iterate over directory entries matching a glob pattern
try (DirectoryStream<Path> stream = Files.newDirectoryStream(
        Path.of("/home/user/docs"), "*.txt")) {
    for (Path entry : stream) {
        System.out.println(entry.getFileName());
    }
}

// Find all .java files under a directory tree
List<Path> javaFiles = new ArrayList<>();
Files.walkFileTree(Path.of("src"), new SimpleFileVisitor<>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        if (file.toString().endsWith(".java")) {
            javaFiles.add(file);
        }
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
        // Skip .git directories
        if (dir.getFileName() != null && dir.getFileName().toString().equals(".git")) {
            return FileVisitResult.SKIP_SUBTREE;
        }
        return FileVisitResult.CONTINUE;
    }
});

// Find all .java files, excluding .git directories
try (Stream<Path> paths = Files.walk(Path.of("src"))) {
    paths.filter(p -> p.toString().endsWith(".java"))
         .filter(p -> !p.startsWith(Path.of("src/.git")))
         .forEach(System.out::println);
}

// From a stream (the channel shares the stream's position)
try (FileInputStream fis = new FileInputStream("data.bin");
     FileChannel channel = fis.getChannel()) {
    // use channel
}

// Directly (recommended for NIO code)
try (FileChannel channel = FileChannel.open(Path.of("data.bin"),
        StandardOpenOption.READ)) {
    // use channel
}

+-------------------+------------------+------------------+
|     capacity      |                  |                  |
+-------------------+------------------+------------------+
|      position     |     remaining    |                  |
+-------------------+------------------+------------------+
0                                                                     limit                                                              capacity

// Heap buffer: backed by a Java byte array, subject to GC
ByteBuffer heap = ByteBuffer.allocate(8192);

// Direct buffer: backed by native memory, NOT subject to GC
ByteBuffer direct = ByteBuffer.allocateDirect(8192);

ByteBuffer buf = ByteBuffer.allocate(256);

buf.put((byte) 1);  // position=1
buf.put((byte) 2);  // position=2
buf.put((byte) 3);  // position=3, limit=256

buf.flip();         // limit=3, position=0  (write mode → read mode)

byte a = buf.get(); // a=1, position=1
byte b = buf.get(); // b=2, position=2

buf.compact();      // copies unread data (byte 3) to index 0, position=1, limit=256
buf.put((byte) 4);  // append after existing data

buf.rewind();       // position=0, limit unchanged (re-read the data)

buf.clear();        // position=0, limit=256 (read mode → write mode)

try (FileChannel channel = FileChannel.open(Path.of("data.bin"), StandardOpenOption.READ)) {
    ByteBuffer buf = ByteBuffer.allocate(8192);
    while (channel.read(buf) != -1) {
        buf.flip();
        while (buf.hasRemaining()) {
            byte b = buf.get();
            // process byte
        }
        buf.clear();
    }
}

// Efficient file copy using transferTo (zero-copy on supported OSes)
try (FileChannel src = FileChannel.open(Path.of("source.bin"), StandardOpenOption.READ);
     FileChannel dst = FileChannel.open(Path.of("dest.bin"),
         StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
    long transferred = 0;
    long size = src.size();
    while (transferred < size) {
        transferred += src.transferTo(transferred, size - transferred, dst);
    }
}

try (FileChannel channel = FileChannel.open(Path.of("large.dat"),
        StandardOpenOption.READ, StandardOpenOption.WRITE)) {
    MappedByteBuffer mbb = channel.map(
        FileChannel.MapMode.READ_WRITE,  // READ_ONLY, READ_WRITE, or PRIVATE
        0,                                // offset
        channel.size());                  // size

    // Direct access to file contents via memory
    mbb.putInt(0, 42);           // write an int at offset 0
    int value = mbb.getInt(0);   // read it back

    // Changes are visible to other programs that have mapped the same file
    // (for READ_WRITE mode). Changes may not be flushed to disk until
    // MappedByteBuffer.force() is called or the channel is closed.
    mbb.force();  // flush to disk
}

// Non-blocking connect
try (SocketChannel channel = SocketChannel.open()) {
    channel.configureBlocking(false);
    channel.connect(new InetSocketAddress("example.com", 80));

    while (!channel.finishConnect()) {
        // do other work while connecting
    }

    ByteBuffer request = ByteBuffer.wrap("GET / HTTP/1.0\r\n\r\n".getBytes(StandardCharsets.UTF_8));
    channel.write(request);

    ByteBuffer response = ByteBuffer.allocate(8192);
    channel.read(response);
    response.flip();
    System.out.println(StandardCharsets.UTF_8.decode(response));
}

// Non-blocking server (simplified — use Selector for real code)
try (ServerSocketChannel server = ServerSocketChannel.open()) {
    server.bind(new InetSocketAddress(8080));
    server.configureBlocking(false);
    while (true) {
        SocketChannel client = server.accept();  // returns null if no connection
        if (client != null) {
            client.configureBlocking(false);
            // handle client
        }
    }
}

try (Selector selector = Selector.open();
     ServerSocketChannel server = ServerSocketChannel.open()) {

    server.bind(new InetSocketAddress(8080));
    server.configureBlocking(false);
    server.register(selector, SelectionKey.OP_ACCEPT);

    while (true) {
        selector.select();  // blocks until at least one channel is ready

        Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
        while (keys.hasNext()) {
            SelectionKey key = keys.next();
            keys.remove();

            if (!key.isValid()) {
                continue;
            }

            if (key.isAcceptable()) {
                SocketChannel client = server.accept();
                client.configureBlocking(false);
                client.register(selector, SelectionKey.OP_READ);
            }

            if (key.isReadable()) {
                SocketChannel client = (SocketChannel) key.channel();
                ByteBuffer buf = ByteBuffer.allocate(8192);
                int bytesRead = client.read(buf);
                if (bytesRead == -1) {
                    key.cancel();
                    client.close();
                    continue;
                }
                buf.flip();
                // process request, then register for write
                client.register(selector, SelectionKey.OP_WRITE, buf);
            }

            if (key.isWritable()) {
                SocketChannel client = (SocketChannel) key.channel();
                ByteBuffer buf = (ByteBuffer) key.attachment();
                client.write(buf);
                if (!buf.hasRemaining()) {
                    key.interestOps(SelectionKey.OP_READ);
                }
            }
        }
    }
}

// Small file: read all at once
String content = Files.readString(Path.of("config.json"));

// Small file: write all at once
Files.writeString(Path.of("output.txt"), "hello, world\n");

// Large file: stream line by line
try (Stream<String> lines = Files.lines(Path.of("access.log"), StandardCharsets.UTF_8)) {
    lines.filter(line -> line.contains(" 500 "))
         .forEach(System.out::println);
}

// Large file: write line by line
try (BufferedWriter writer = new BufferedWriter(
        new FileWriter("output.txt", StandardCharsets.UTF_8))) {
    for (String line : data) {
        writer.write(line);
        writer.newLine();
    }
}

// Lazy count (constant memory)
long errorCount;
try (Stream<String> lines = Files.lines(Path.of("server.log"), StandardCharsets.UTF_8)) {
    errorCount = lines.filter(line -> line.startsWith("[ERROR]")).count();
}

// With state (e.g., CSV parsing)
try (BufferedReader reader = new BufferedReader(
        new FileReader("data.csv", StandardCharsets.UTF_8))) {
    String header = reader.readLine();  // skip header
    String line;
    while ((line = reader.readLine()) != null) {
        String[] fields = line.split(",");
        // process fields
    }
}

// Read/write binary with precise positioning
try (FileChannel channel = FileChannel.open(Path.of("data.bin"),
        StandardOpenOption.READ, StandardOpenOption.WRITE)) {
    ByteBuffer buf = ByteBuffer.allocate(1024);
    channel.read(buf, 4096);   // read 1024 bytes at offset 4096
    buf.flip();
    buf.rewind();
    channel.write(buf, 8192);  // write at offset 8192
}

// Create a temporary file
Path temp = Files.createTempFile("prefix-", ".suffix");

// In a specific directory
Path temp = Files.createTempFile(Path.of("/tmp/myapp"), "data-", ".bin");

// Create a temporary directory
Path tempDir = Files.createTempDirectory("myapp-");

// DELETE_ON_CLOSE: deleted when the channel is closed
try (FileChannel channel = FileChannel.open(
        Files.createTempFile("work-", ".dat"),
        StandardOpenOption.DELETE_ON_CLOSE,
        StandardOpenOption.READ,
        StandardOpenOption.WRITE)) {
    // work with the file
}

// Exclusive lock (blocks until acquired)
try (FileChannel ch = FileChannel.open(Path.of("data.db"),
        StandardOpenOption.READ, StandardOpenOption.WRITE);
     FileLock lock = ch.lock()) {
    // atomic read-modify-write
}

// Shared lock (multiple readers OK, writers blocked)
try (FileChannel ch = FileChannel.open(Path.of("data.db"), StandardOpenOption.READ);
     FileLock lock = ch.lock(0, Long.MAX_VALUE, true)) {
    // read-only operation
}

// Non-blocking attempt
try (FileChannel ch = FileChannel.open(Path.of("data.db"),
        StandardOpenOption.READ, StandardOpenOption.WRITE)) {
    FileLock lock = ch.tryLock();
    if (lock == null) {
        // lock not available, handle contention
    }
}

import java.util.ArrayList;

public class Example {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Alice");
        list.add("Bob");
        list.add("Charlie");

        for (String name : list) {
            System.out.println(name);
        }
    }
}