Java I/O: Streams, Scanner, BufferedReader

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

public class Unwrap {

    // The bottom of the stack: bytes, and nothing else. Build everything on this.
    static InputStream raw(String text) {
        return new ByteArrayInputStream(text.getBytes(StandardCharsets.UTF_8));
    }

    // Layer 0: read ONE byte and return the number. -1 when there is nothing there.
    static int firstRawByte(String text) throws IOException { return 0; }  // TODO

    // Layer 0 again: count the bytes, one read() at a time.
    static int byteCount(String text) throws IOException { return 0; }  // TODO

    // TODO: layer 1. Wrap raw() so you get characters instead of bytes, then count them.
    static int charCount(String text) throws IOException { return 0; }  // TODO

    // TODO: layer 2. Wrap layer 1 so you get whole lines.
    static String firstLine(String text) throws IOException { return null; }  // TODO
    static List<String> allLines(String text) throws IOException { return null; }  // TODO

    // TODO: the same job with a Scanner. Compare the code with allLines.
    static String scannerFirstLine(String text) { return null; }  // TODO

    // Is one byte one character for this text? Answer it by measuring, not by guessing.
    static boolean oneByteIsTheWholeCharacter(String text) throws IOException { return true; }  // TODO

    public static void main(String[] args) throws IOException {
        // TODO: print the byte count and the character count for "Atlas" and for "é"
    }
}

import java.io.*;
import java.nio.file.*;

public class Buffered {

    // Given. The exercise makes its own file and cleans it up.
    static Path makeFile(int lines) throws IOException {
        Path path = Files.createTempFile("layers-of-logic-buffered-", ".txt");
        try (PrintWriter out = new PrintWriter(Files.newBufferedWriter(path))) {
            for (int i = 0; i < lines; i++) out.println("unit " + i + " readiness " + (i % 100));
        }
        return path;
    }

    static void deleteFile(Path path) throws IOException {
        Files.deleteIfExists(path);
    }

    // ---- bytes. One read() on a FileInputStream is one system call. ----

    // TODO: read the file one byte at a time with a plain FileInputStream
    static int countRawBytes(Path path) throws IOException { return 0; }

    // TODO: the same, wrapped in a BufferedInputStream
    static int countBufferedBytes(Path path) throws IOException { return 0; }

    // TODO: time each of the two above. Return milliseconds.
    static long timeRawBytes(Path path) throws IOException { return 0; }
    static long timeBufferedBytes(Path path) throws IOException { return 0; }

    // ---- characters. Predict this gap before you measure it. ----

    // TODO: one char at a time from a plain FileReader
    static long timeUnbufferedChars(Path path) throws IOException { return 0; }

    // TODO: one char at a time from a BufferedReader
    static long timeBufferedChars(Path path) throws IOException { return 0; }

    // ---- lines ----

    // TODO: count the lines with readLine
    static int countLines(Path path) throws IOException { return 0; }
    static long timeByLine(Path path) throws IOException { return 0; }

    // TODO: does FileReader have a readLine method? Ask it, do not guess.
    static boolean fileReaderHasReadLine() { return true; }

    public static void main(String[] args) throws IOException {
        Path path = makeFile(120_000);
        try {
            // TODO: print all five timings and compare the two ratios
        } finally {
            deleteFile(path);
        }
    }
}

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

public class Skipped {

    // Given. A Scanner over a String, so the input is repeatable.
    private static Scanner scannerOn(String input) {
        return new Scanner(new ByteArrayInputStream(input.getBytes(StandardCharsets.UTF_8)),
                StandardCharsets.UTF_8);
    }

    // The bug, kept on purpose. Run it before you fix anything.
    static int buggyId(String input) {
        try (Scanner scanner = scannerOn(input)) {
            return scanner.nextInt();
        }
    }

    static String buggyName(String input) {
        try (Scanner scanner = scannerOn(input)) {
            scanner.nextInt();
            return scanner.nextLine();       // appears to be skipped
        }
    }

    // TODO: is the name null, or is it something zero characters long? Do not guess.
    static boolean buggyNameIsNull(String input) { return true; }

    // TODO fix 1: consume the leftover newline and throw it away
    static String fixWithThrowawayNextLine(String input) { return null; }

    // TODO fix 2: read whole lines only, and parse the number yourself
    static String fixWithParseInt(String input) { return null; }

    // TODO fix 3: no Scanner at all
    static String fixWithBufferedReader(String input) throws IOException { return null; }

    // TODO: the id, read the way fix 2 reads it
    static int fixedId(String input) { return 0; }

    // TODO: after writing all three, decide. Is the throwaway line the clearest?
    static boolean throwawayLineIsTheClearestFix() { return true; }

    public static void main(String[] args) throws IOException {
        String input = "101\nAtlas Recon\n";
        // TODO: print the buggy name and its length, then all three fixes
    }
}

import java.io.*;
import java.nio.file.*;
import java.util.*;

public class LoadRegistry {

    record Unit(String name, int id, double readiness, boolean active) { }

    // What one pass over the file produced: the good rows, and a note per bad one.
    record Loaded(List<Unit> units, List<String> problems) { }

    static final String SAMPLE = """
            name,id,readiness,active
            Atlas,101,88.5,true
            Beacon,102,42.0,true
            BadRow,not-a-number,50,true
            Cipher,103,95.5,false
            """;

    // Given. The exercise makes its own file and cleans it up.
    static Path writeFile(String contents) throws IOException {
        Path path = Files.createTempFile("layers-of-logic-registry-", ".csv");
        Files.writeString(path, contents);
        return path;
    }

    static Path writeSample() throws IOException { return writeFile(SAMPLE); }

    static void deleteFile(Path path) throws IOException { Files.deleteIfExists(path); }

    // TODO: read it back with try-with-resources and a BufferedReader.
    //   - skip the header, which is line 1
    //   - report every bad row as "line N: something useful"
    //   - keep going after a bad row rather than stopping
    //   - check the field count before reading position 3
    static Loaded load(Path path) throws IOException {
        return new Loaded(List.of(), List.of());  // TODO
    }

    // TODO: the average over the units that loaded. Nothing loaded is 0.0, not a crash.
    static double averageReadiness(List<Unit> units) { return 0.0; }

    public static void main(String[] args) throws IOException {
        Path path = writeSample();
        try {
            // TODO: load it, print each unit, print each problem, print a summary
        } finally {
            deleteFile(path);
        }
    }
}