Union and Intersection Count

When two ArrayLists represent collections of values, two natural questions emerge: how many elements appear in both (intersection), and how many distinct elements appear in either (union)?

The implementation reduces to a familiar pattern: traverse one list, search the other, and tally based on membership. A small helper method — containsValue — makes the logic readable and reusable.

On the AP exam, this combined pattern appears in FRQs that compare two collections — common membership, shared items, distinct totals.

The contains helper

private boolean containsValue(ArrayList<String> list, String target) {
    for (String s : list) {
        if (s.equals(target)) return true;
    }
    return false;
}

This is a hand-written existence check using .equals() — the AP-standard idiom for Strings or objects.

Intersection count

public int intersectionCount(ArrayList<String> a, ArrayList<String> b) {
    int count = 0;
    for (String x : a) {
        if (containsValue(b, x)) {
            count++;
        }
    }
    return count;
}

For every element of a, ask "is it also in b?" Tally each hit. Result: the number of elements appearing in both lists (counting duplicates in a; see edge cases below).

Union count (distinct elements in either)

public int unionCount(ArrayList<String> a, ArrayList<String> b) {
    int count = a.size();
    for (String x : b) {
        if (!containsValue(a, x)) {
            count++;
        }
    }
    return count;
}

Start with every element of a. Add each element of b that isn't already in a. Result: count of distinct values across both lists — assuming a itself has no duplicates.

Edge cases

• Duplicates in a. If a contains "x" twice, intersection counts "x" twice (once for each occurrence). Union over-counts unless you de-duplicate first.
• Empty list. Intersection with an empty list is 0. Union with an empty list equals the size of the other.
• Identical lists. Intersection equals a.size(). Union equals a.size() too (no new elements added).