Set operations: union, intersection and difference

For this lesson, we'll focus on Java's built-in operations (addAll, retainAll, removeAll, containsAll, Collections.disjoint), how to use them without mutating your inputs, stream alternatives, Guava's view-style utilities, the real AbstractSet.removeAll performance trap, and specialized set algebra with TreeSet ranges and EnumSet bit operations. Interviewers ask this because the code is small, but the mistakes are very common.

01Picture it first: Venn diagrams with side effects

Think of two sets as two circles. The math is clean, but the Java methods are more like scissors and glue: addAll, retainAll and removeAll modify the receiver. If the receiver is an input parameter, you may have changed your caller's data.

Here is the picture you should keep in your head while writing code.

Fig. 1

Four Venn diagrams show union as both circles, intersection as the overlap, difference as the left-only region, and symmetric difference as both non-overlapping regions

The default habit is copy first, mutate the copy. That makes the method honest: callers give you sets, you return a new set, and nobody is surprised later.

02The core operations under the hood

import java.util.HashSet;
import java.util.Set;

public class SetAlgebra {
    public static void main(String[] args) {
        Set<String> paid = Set.of("u1", "u2", "u3");
        Set<String> active = Set.of("u2", "u3", "u4");

        Set<String> union = new HashSet<>(paid);
        union.addAll(active);

        Set<String> intersection = new HashSet<>(paid);
        intersection.retainAll(active);

        Set<String> difference = new HashSet<>(paid);
        difference.removeAll(active);

        Set<String> symmetricDifference = new HashSet<>(union);
        symmetricDifference.removeAll(intersection);

        System.out.println(union);               // [u1, u2, u3, u4] in some order
        System.out.println(intersection);        // [u2, u3] in some order
        System.out.println(difference);          // [u1]
        System.out.println(symmetricDifference); // [u1, u4] in some order
    }
}

The operations are small because Set already gives us uniqueness. addAll adds every element from the other collection, but duplicates collapse. retainAll keeps only elements that the other collection contains. removeAll removes every element that the other collection contains.

Notice the receiver each time. We mutate union, intersection, difference and symmetricDifference, not paid or active. If you used Set.of, the inputs are unmodifiable anyway, but in production they are often mutable HashSets stored in a cache or object field.

The four operations in one table

For symmetric difference, I prefer the union-minus-intersection version in interviews because it reads like the Venn diagram. If allocation is tight, you can also build a - b, build b - a, then addAll those two sets.

static <E> Set<E> symmetricDifference(Set<E> a, Set<E> b) {
    Set<E> leftOnly = new HashSet<>(a);
    leftOnly.removeAll(b);

    Set<E> rightOnly = new HashSet<>(b);
    rightOnly.removeAll(a);

    leftOnly.addAll(rightOnly);
    return leftOnly;
}

03Relationship checks: subset, superset and disjoint

Some set questions do not ask you to build a new set. They ask about a relationship between two sets.