The Collection Interface

import java.util.*;

public class RemoveTrap {

    // Take out whatever sits at this index, and return it.
    static Integer removeAtPosition(List<Integer> l, int index) {
        return null; // TODO
    }

    // Take out the element EQUAL to this value. Return whether anything went.
    static boolean removeTheValue(List<Integer> l, int value) {
        return false; // TODO
    }

    static boolean removeFromSet(Set<Integer> s, int value) {
        return false; // TODO
    }

    public static void main(String[] args) {
        List<Integer> a = new ArrayList<>(List.of(10, 20, 30, 40));
        List<Integer> b = new ArrayList<>(List.of(10, 20, 30, 40));

        // TODO: predict both, including the RETURN VALUES, before running
        System.out.println("a.remove(1)                  = " + a.remove(1) + "  -> " + a);
        System.out.println("b.remove(Integer.valueOf(1)) = " + b.remove(Integer.valueOf(1)) + "  -> " + b);

        // TODO: why does the same call on a Set have no ambiguity?
    }
}

import java.util.*;

public class Bulk {

    // Who is on duty AND injured. Order follows onDuty.
    static List<String> onDutyAndInjured(List<String> onDuty, List<String> injured) {
        return List.of(); // TODO: retainAll
    }

    // Who is on duty but NOT injured.
    static List<String> onDutyNotInjured(List<String> onDuty, List<String> injured) {
        return List.of(); // TODO: removeAll
    }

    // Is every injured unit also on duty?
    static boolean allInjuredAreOnDuty(List<String> onDuty, List<String> injured) {
        return false; // TODO: containsAll
    }

    public static void main(String[] args) {
        List<String> onDuty  = new ArrayList<>(List.of("Atlas", "Beacon", "Cipher", "Drift"));
        List<String> injured = List.of("Beacon", "Ember");

        // TODO: print all three answers
        // TODO: write the intersection as a hand loop too, and compare the code
    }
}

import java.util.*;

public class AddReturns {

    // Each name once, in the order it was first seen. Use add's return value.
    static List<String> firstSightings(String[] log) {
        return List.of(); // TODO
    }

    // Each repeated name once, in the order the repeat happened.
    static List<String> duplicates(String[] log) {
        return List.of(); // TODO
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Set<String>  set  = new HashSet<>();

        System.out.println("list.add(\"a\") = " + list.add("a"));
        System.out.println("list.add(\"a\") = " + list.add("a"));
        System.out.println("set.add(\"a\")  = " + set.add("a"));
        System.out.println("set.add(\"a\")  = " + set.add("a"));

        String[] log = {"Atlas", "Beacon", "Atlas", "Cipher", "Beacon", "Atlas"};
        // TODO: print both answers
    }
}

import java.util.*;

public class Unsupported {

    // Attempt it. Return "ok" or "UnsupportedOperationException".
    static String tryAdd(List<Integer> l) {
        return "ok"; // TODO: add 99
    }

    static String trySet(List<Integer> l) {
        return "ok"; // TODO: put 99 at slot 0
    }

    static String tryRemove(List<Integer> l) {
        return "ok"; // TODO: take out position 0
    }

    public static void main(String[] args) {
        // TODO: predict all nine before running
        // TODO: print the nine results as a table
        // TODO: explain why Arrays.asList allows set but not add
    }
}