Java I/O and NIO

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;

public class Main {
    public static void main(String[] args) throws IOException {
        // A "stream" is a one-way flow of data: bytes for binary,
        // characters for text. Reader/Writer handle TEXT; you wrap
        // them in Buffered* so you read/write a chunk at a time
        // instead of one slow character at a time.
        String config = "host=localhost\nport=8080\ndb=myapp";

        // WRITE — String-backed Writer so this runs anywhere.
        // With a real file you'd use new FileWriter("config.txt").
        StringWriter sink = new StringWriter();
        // try-with-resources auto-closes bw at the end of the block —
        // no manual close(), no finally. The () after try holds the
        // resource; anything AutoCloseable goes there.
        try (BufferedWriter bw = new BufferedWriter(sink)) {
            bw.write(config);              // buffered: held in memory...
        }                                  // ...flushed + closed here
        System.out.println("Wrote " + config.length() + " chars");

        // READ line by line — readLine() returns null at end of stream.
        try (BufferedReader br = new BufferedReader(new StringReader(sink.toString()))) {
            String line;                   // declared outside the loop
            int n = 1;
            while ((line = br.readLine()) != null) {  // null = no more lines
                System.out.println("Line " + (n++) + ": " + line);
            }
        }
    }
}

Wrote 31 chars
Line 1: host=localhost
Line 2: port=8080
Line 3: db=myapp

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) throws IOException {
        // Path = a location on disk (the modern replacement for File).
        // Files = a toolbox of static helpers that act on a Path.
        // We make a real temp file so the example is self-contained.
        Path file = Files.createTempFile("demo", ".log");

        // WRITE a whole small file in ONE call (Java 11+).
        // Always pass a charset so it behaves the same on every OS.
        Files.writeString(file,
            "ERROR boot failed\nINFO ready\nERROR disk full\nDEBUG tick\nERROR timeout",
            StandardCharsets.UTF_8);
        System.out.println("Wrote " + Files.size(file) + " bytes");

        // READ it all back as one String (Java 11+) — small files only.
        String text = Files.readString(file, StandardCharsets.UTF_8);
        System.out.println("readString got " + text.length() + " chars");

        // READ as a List of lines — handy when you want every line at once.
        List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);
        System.out.println("readAllLines got " + lines.size() + " lines");

        // STREAM lines lazily — safe for HUGE files (one line in memory
        // at a time). Files.lines holds an open file, so close it with
        // try-with-resources.
        try (Stream<String> stream = Files.lines(file, StandardCharsets.UTF_8)) {
            long errors = stream.filter(l -> l.contains("ERROR")).count();
            System.out.println("Found " + errors + " ERROR lines");
        }

        Files.delete(file);                // tidy up
        System.out.println("Cleaned up: " + !Files.exists(file));
    }
}

Wrote 67 bytes
readString got 67 chars
readAllLines got 5 lines
Found 3 ERROR lines
Cleaned up: true

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        // 🎯 YOUR TURN — fill in the blanks marked with ___
        Path notes = Files.createTempFile("notes", ".txt");

        // 1) Write three lines to the file using Files.writeString.
        //    Separate lines with \n and pass the UTF_8 charset.
        Files.writeString(notes, "buy milk\nwalk dog\ncall mum", ___);
        //                                                         👆 the charset

        // 2) Read every line back as a List<String>.
        List<String> lines = Files.___(notes, StandardCharsets.UTF_8);
        //                         👆 the method that returns a List of lines

        // 3) Print how many lines you read.
        System.out.println("You have " + lines.___() + " notes");
        //                                       👆 List method for the count

        Files.delete(notes);

        // ✅ Expected output:
        // You have 3 notes
    }
}

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) throws IOException {
        // 🎯 YOUR TURN — count the WARN lines without loading the
        // whole file into memory. Fill in the blanks marked with ___
        Path log = Files.createTempFile("app", ".log");
        Files.writeString(log,
            "INFO start\nWARN low disk\nINFO ok\nWARN slow query\nINFO done",
            StandardCharsets.UTF_8);

        // 1) Open a lazy Stream of the file's lines.
        //    Use try-with-resources so the file is closed for you.
        try (Stream<String> lines = Files.___(log, StandardCharsets.UTF_8)) {
            //                             👆 the lazy streaming method
            // 2) Keep only lines that contain "WARN", then count them.
            long warnings = lines.filter(l -> l.contains("___")).count();
            //                                                👆 the text to match
            System.out.println("Warnings: " + warnings);
        }

        Files.delete(log);

        // ✅ Expected output:
        // Warnings: 2
    }
}

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.nio.channels.FileChannel;

public class Main {
    public static void main(String[] args) throws IOException {
        // A Channel is a two-way pipe to a file or socket. A ByteBuffer
        // is a fixed-size box of bytes the channel reads into / writes
        // from. This is the low-level engine Files.* uses for you — you
        // rarely need it, but it powers high-performance code.
        Path file = Files.createTempFile("channel", ".bin");

        byte[] data = "Hello, NIO!".getBytes(StandardCharsets.UTF_8);
        try (FileChannel ch = FileChannel.open(file, StandardOpenOption.WRITE)) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put(data);          // fill the buffer (write mode)
            buffer.flip();             // FLIP: switch to read mode so the
                                       // channel knows where the data ends
            int written = ch.write(buffer);
            System.out.println("Wrote " + written + " bytes");
        }

        try (FileChannel ch = FileChannel.open(file, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate((int) ch.size());
            ch.read(buffer);           // fill the buffer from the file
            buffer.flip();             // flip before reading it back out
            String text = StandardCharsets.UTF_8.decode(buffer).toString();
            System.out.println("Read back: " + text);
        }

        Files.delete(file);
    }
}

Wrote 11 bytes
Read back: Hello, NIO!

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        // 🎯 MINI-CHALLENGE: word counter
        // 1. Create a temp file and write a sentence into it with
        //    Files.writeString (remember the UTF_8 charset).
        // 2. Read it back with Files.readString.
        // 3. Split the text on spaces:  text.split(" ")  gives a String[].
        // 4. Print: "Word count: N"   (an array's length is array.length).
        // 5. Delete the temp file when you're done.
        //
        // ✅ Expected (text = "the quick brown fox"): Word count: 4

        // your code here
    }
}