The Collections Framework

import java.util.*;

public class TheTrade {

    // Walk every used slot and return the largest.
    static int findMaxUnsorted(int[] a, int size) {
        return 0; // TODO
    }

    // The array is already sorted. One read, no loop.
    static int findMaxSorted(int[] a, int size) {
        return 0; // TODO
    }

    // Put v at the end. Grow the array first if every slot is used.
    static int[] insertUnsorted(int[] a, int size, int v) {
        return a; // TODO
    }

    // Put v where it belongs, shifting the rest right. Grow first if full.
    static int[] insertSorted(int[] a, int size, int v) {
        return a; // TODO
    }

    public static void main(String[] args) {
        // TODO: build both arrangements with 100_000 numbers
        // TODO: time 10_000 max-lookups on each
        // TODO: time 10_000 insertions into each
        // TODO: print the table
    }
}

import java.util.*;

public class Swap {

    // One method that accepts EVERY kind of container: List, Set and Deque alike.
    static String report(Collection<String> items) {
        return ""; // TODO
    }

    // Whichever group holds the most items.
    static Collection<String> largest(Collection<Collection<String>> groups) {
        return null; // TODO
    }

    public static void main(String[] args) {
        ArrayList<String> a = new ArrayList<>(List.of("Atlas", "Beacon"));
        LinkedList<String> l = new LinkedList<>(List.of("Cipher"));
        HashSet<String> h = new HashSet<>(List.of("Drift"));
        ArrayDeque<String> d = new ArrayDeque<>(List.of("Ember"));

        // TODO: pass all four to report()

        // TODO: declare a variable as ArrayList, call ensureCapacity() on it,
        //       then change the declared type to LinkedList. Record where the
        //       error appears, and how far it is from the line you changed.
    }
}

import java.util.*;

public class NotACollection {

    // Ask the type system rather than trusting the diagram.
    static boolean mapIsCollection() { return true;  /* TODO */ }
    static boolean listIsCollection() { return false; /* TODO */ }
    static boolean mapIsIterable()   { return true;  /* TODO */ }

    // Three loops that DO work over a Map. Each returns a sorted list.
    static List<String> viaKeySet(Map<String, Integer> m) {
        return List.of(); // TODO
    }

    static List<Integer> viaValues(Map<String, Integer> m) {
        return List.of(); // TODO
    }

    // Each entry becomes "key=value", for example "Atlas=88".
    static List<String> viaEntrySet(Map<String, Integer> m) {
        return List.of(); // TODO
    }

    public static void main(String[] args) {
        System.out.println("Is Map a Collection?    " + mapIsCollection());
        System.out.println("Is List a Collection?   " + listIsCollection());
        System.out.println("Is Map Iterable?        " + mapIsIterable());

        // TODO: print every interface HashMap and ArrayList implement, and compare
        // TODO: try to for-each over a Map directly. Read the error, then comment it out
    }
}

import java.util.*;

public class RegistryCollections {

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

    // In Phase IV this was a Unit[] with a separate size counter, a capacity
    // check before every add, a grow-and-copy method, and a shift loop on remove.
    // None of that appears below. That absence is the exercise.

    static List<Unit> newRoster() {
        return null; // TODO
    }

    // true when a unit was actually removed.
    static boolean removeById(List<Unit> roster, int id) {
        return false; // TODO
    }

    // 0.0 for an empty roster.
    static double averageReadiness(List<Unit> roster) {
        return 0.0; // TODO
    }

    // null for an empty roster.
    static Unit mostReady(List<Unit> roster) {
        return null; // TODO
    }

    // A new list. The roster passed in must not change.
    static List<Unit> activeOnly(List<Unit> roster) {
        return null; // TODO
    }

    public static void main(String[] args) {
        // TODO: build a roster, add units, report count, average and best
        // TODO: remove one by id
        // TODO: change newRoster to return a LinkedList and confirm nothing else moves
        // TODO: list what you deleted compared with the Phase IV version
    }
}