The Collection Interface

Collection holds the methods that make sense for every container, and nothing else.

Collection<Integer> c = new ArrayList<>();
c = new LinkedList<>();
c = new HashSet<>();
c = new ArrayDeque<>();      // all of these compile

Whatever is really behind the variable, the same methods are available. That is polymorphism from Section 7.2, applied across a whole framework.

The methods, in groups

The rule for what belongs here

One question decides it: does this make sense for every collection?

This keeps Collection small and honest. If a method were promoted here that some implementation cannot support, that implementation would have to throw an exception from a method it was forced to declare.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. What decides whether a method belongs on `Collection` rather than on `List` or `Set`?

   Show the answer

   One question: does it make sense for every collection?

   size() does. Every container has a count. contains() does. Every container can be asked whether something is in it. So both live on Collection.

   get(3) does not. A Set has no positions, so there is nothing for it to return. It lives on List.

   The rule keeps Collection small and honest. If a method were promoted here that some implementation cannot support, that implementation would have to throw an exception from a method it was forced to declare. The framework does have a few of those, and they are considered mistakes.

2. `Collection.add` returns a `boolean`. When is it ever false?

   Show the answer

   When the collection refused the element.

   A List always accepts, so add is always true there. It is easy to conclude the return value is pointless.

   A Set rejects duplicates. set.add(3) on a set that already holds 3 returns false and changes nothing.

   The boolean means "did the collection change because of this call". That is genuinely useful: if (seen.add(x)) { } is a one line way to do something only the first time you meet a value.

3. `list.remove(1)` and `list.remove(Integer.valueOf(1))` on a `List<Integer>`. What does each one do?

   Show the answer

   remove(1) removes the element at position 1. On [10, 20, 30, 40] it removes 20 and returns it.

   remove(Integer.valueOf(1)) tries to remove the value 1. It is not there, so it returns false and changes nothing.

   The cause is the overload rule from Section 5.1. List has both remove(int index) and remove(Object o). Passing a plain int matches remove(int) in the first resolution pass, using no conversion at all, so boxing is never considered.

   Notice the return types differ too: one gives you the removed element, the other gives you a boolean. Two methods, one name, completely different jobs.

Start with the warm-ups. Continue to practice exercises when the basic idea works. Challenges are optional: skip them on a first pass and return after the next lesson.

1. Warm up: one idea with close guidance.
2. Practice: combine the idea with earlier material.
3. Challenge: investigate an edge case or implementation detail.

3 exercises55 pointsabout 60 minutes

class RemoveTrap {
    static Integer removeAtPosition(List<Integer> l, int index)
    static boolean removeTheValue(List<Integer> l, int value)
    static boolean removeFromSet(Set<Integer> s, int value)
}

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?
    }
}

class Bulk {
    static List<String> onDutyAndInjured(List<String> onDuty, List<String> injured)
    static List<String> onDutyNotInjured(List<String> onDuty, List<String> injured)
    static boolean allInjuredAreOnDuty(List<String> onDuty, List<String> injured)
}

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
    }
}

class Unsupported {
    static String tryAdd(List<Integer> l)
    static String trySet(List<Integer> l)
    static String tryRemove(List<Integer> l)
}

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
    }
}