Java HashSet: Unique Values, Membership, and Set Math

A Set Stores Unique Values

A HashSet (from java.util) is a collection that holds each value at most once. There are no keys and no values paired up like in a HashMap - just a bag of distinct elements. Its whole job is to answer one question fast: "is this thing in here?"

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

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("java");   // duplicate - ignored

        System.out.println(tags.contains("java"));     // true
        System.out.println(tags.contains("frontend")); // false
        System.out.println(tags.size());               // 2
    }
}

There is one type parameter, <ElementType>. As with ArrayList and HashMap, you typically type the variable as the Set interface and construct a HashSet.

add Returns Whether It Was New

add does not just store the value - it returns a boolean telling you whether the set actually changed. Adding a value that is already present returns false and leaves the set untouched.

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

public class Main {
    public static void main(String[] args) {
        Set<Integer> seen = new HashSet<>();

        System.out.println(seen.add(7));  // true  - 7 was new
        System.out.println(seen.add(7));  // false - already there
        System.out.println(seen);
    }
}

That return value is genuinely useful: if (!seen.add(x)) { /* x is a repeat */ } lets you detect duplicates in a single line as you go.

Removing Duplicates From a List

Because a set rejects repeats, the fastest way to dedupe a collection is to dump it into one. A HashSet constructor accepts any other collection:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Ada", "Boris", "Ada", "Chen", "Boris"));

        Set<String> unique = new HashSet<>(names);
        System.out.println(unique);          // each name once
        System.out.println(unique.size());   // 3

        // need a List back?
        List<String> deduped = new ArrayList<>(unique);
        System.out.println(deduped.size());  // 3
    }
}

This is the most common reason beginners reach for a set. Just know you lose the original ordering in the round trip - use LinkedHashSet if order matters (covered below).

contains, remove, and size

The everyday operations mirror the other collections:

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

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("api");

        System.out.println(tags.contains("api"));  // true
        System.out.println(tags.size());           // 3

        tags.remove("backend");
        System.out.println(tags.contains("backend")); // false

        tags.clear();
        System.out.println(tags.isEmpty());         // true
    }
}

The big win over an ArrayList is contains. A list has to walk every element to answer it (O(n)); a HashSet jumps almost straight to the answer (roughly O(1)). When you find yourself calling list.contains(...) inside a loop, that is usually the signal to switch to a set.

Set Math: Union, Intersection, Difference

Sets shine when you combine them. The methods read like plain English once you know which is which:

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

public class Main {
    public static void main(String[] args) {
        Set<Integer> a = new HashSet<>(Set.of(1, 2, 3, 4));
        Set<Integer> b = new HashSet<>(Set.of(3, 4, 5, 6));

        Set<Integer> union = new HashSet<>(a);
        union.addAll(b);            // everything in either set
        System.out.println(union);  // 1 2 3 4 5 6

        Set<Integer> intersection = new HashSet<>(a);
        intersection.retainAll(b);  // only what's in both
        System.out.println(intersection); // 3 4

        Set<Integer> difference = new HashSet<>(a);
        difference.removeAll(b);    // in a but not b
        System.out.println(difference);   // 1 2
    }
}

The key gotcha: addAll, retainAll, and removeAll mutate the set they're called on. That's why each example copies a into a fresh HashSet first - otherwise you'd destroy your original. Build a new set for each result.

HashSet Does Not Keep Order

Like HashMap, a HashSet makes no promise about iteration order, and the order can differ between runs. If you need predictability:

• LinkedHashSet preserves insertion order - the order you added elements.
• TreeSet keeps elements sorted by natural ordering (or a Comparator you supply).

import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        Set<String> insertion = new LinkedHashSet<>();
        insertion.add("gamma");
        insertion.add("alpha");
        insertion.add("beta");
        System.out.println(insertion);  // [gamma, alpha, beta]

        Set<String> sorted = new TreeSet<>(insertion);
        System.out.println(sorted);      // [alpha, beta, gamma]
    }
}

All three implement the Set interface, so swapping between them is a one-line change to the constructor.

Elements Must Be Hashable

A HashSet is backed by a HashMap under the hood, so the same rule applies: it locates elements by hashing them, which means an element's hashCode() and equals() must agree. Built-in types like String and Integer already get this right, which is why duplicate "java" strings collapse correctly above. If you store instances of your own class, override both equals and hashCode - otherwise two objects that are "equal" in meaning will be treated as distinct, and contains and dedup will silently fail.

Next: Iterating Collections

You've now met the three workhorse collections - ArrayList, HashMap, and HashSet. Each one you walk through a little differently, and there are subtle traps (like modifying a collection while looping over it). Next we'll pull it all together and cover iterating collections cleanly with the for-each loop, iterators, and forEach.