Java HashSet Class: Complete Guide to Operations, Methods, and Set Theory

Java HashSet Class

Explore the Java HashSet class—its creation, core methods, and practical set operations—through concise examples.

The HashSet class, part of Java’s Collections Framework, implements the Set interface and offers hash‑table based storage.

Creating a HashSet

First, import java.util.HashSet:

import java.util.HashSet;

Then create a HashSet with a specific capacity and load factor:

HashSet<Integer> numbers = new HashSet<>(8, 0.75); // capacity=8, loadFactor=0.75

Parameters:

• capacity – initial bucket count (8 in this example).
• loadFactor – threshold that triggers resizing (0.75 means resize when 75% full).

Using defaults is also common:

HashSet<Integer> numbers1 = new HashSet<>(); // capacity=16, loadFactor=0.75

HashSet Methods

Below are the most frequently used methods:

• add(T element) – inserts a single element.
• addAll(Collection<? extends T> c) – bulk insertion.
• remove(Object o) – deletes a specific element.
• removeAll(Collection<? extends Object> c) – clears multiple elements.
• contains(Object o) – checks presence.
• size() – number of elements.
• clear() – removes all entries.
• clone() – creates a shallow copy.
• isEmpty() – tests if empty.
• containsAll(Collection<? extends Object> c) – subset check.

Inserting Elements

Example using add and addAll:

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> evenNumber = new HashSet<>();
        evenNumber.add(2);
        evenNumber.add(4);
        evenNumber.add(6);
        System.out.println("HashSet: " + evenNumber);

        HashSet<Integer> numbers = new HashSet<>();
        numbers.addAll(evenNumber);
        numbers.add(5);
        System.out.println("New HashSet: " + numbers);
    }
}

Output

HashSet: [2, 4, 6]
New HashSet: [2, 4, 5, 6]

Accessing Elements

Iterate with Iterator:

import java.util.HashSet;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("HashSet: " + numbers);

        Iterator<Integer> iterate = numbers.iterator();
        System.out.print("HashSet using Iterator: ");
        while(iterate.hasNext()) {
            System.out.print(iterate.next() + ", ");
        }
    }
}

Output

HashSet: [2, 5, 6]
HashSet using Iterator: 2, 5, 6,

Removing Elements

Single removal and clearing the set:

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("HashSet: " + numbers);

        boolean removed = numbers.remove(5);
        System.out.println("Is 5 removed? " + removed);

        boolean cleared = numbers.removeAll(numbers);
        System.out.println("Are all elements removed? " + cleared);
    }
}

Output

HashSet: [2, 5, 6]
Is 5 removed? true
Are all elements removed? true

Set Operations

HashSet’s bulk methods support classic set theory operations.

Union

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> evenNumbers = new HashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);

        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(1);
        numbers.add(3);

        numbers.addAll(evenNumbers);
        System.out.println("Union is: " + numbers);
    }
}

Output

Union is: [1, 2, 3, 4]

Intersection

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> primeNumbers = new HashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);

        HashSet<Integer> evenNumbers = new HashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);

        evenNumbers.retainAll(primeNumbers);
        System.out.println("Intersection is: " + evenNumbers);
    }
}

Output

Intersection is: [2]

Difference

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> primeNumbers = new HashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        primeNumbers.add(5);

        HashSet<Integer> oddNumbers = new HashSet<>();
        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);

        primeNumbers.removeAll(oddNumbers);
        System.out.println("Difference: " + primeNumbers);
    }
}

Output

Difference: [2]

Subset Check

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);

        HashSet<Integer> primeNumbers = new HashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);

        boolean isSubset = numbers.containsAll(primeNumbers);
        System.out.println("Is primeNumbers a subset of numbers? " + isSubset);
    }
}

Output

Is primeNumbers a subset of numbers? true

Additional Methods

Method	Description
clone()	Creates a shallow copy of the set.
contains()	Checks if an element exists.
isEmpty()	Returns true if the set is empty.
size()	Number of elements in the set.
clear()	Removes all elements.

For a full list, refer to the official Java documentation.

Why Use HashSet?

When random access is required, HashSet offers O(1) performance thanks to its hash table backing. Each element’s hashCode() guarantees uniqueness, preventing duplicates. However, HashSet is not thread‑safe; external synchronization is needed for concurrent use.

Note: Because HashSet is unsynchronized, multiple threads modifying it concurrently can corrupt the data structure.