Java HashSet and TreeSet Exercises: 25 Coding Problems with Solutions

This collection of 25 Java exercises covers the full Set family, HashSet and TreeSet, and how they differ in ordering, duplicate handling, and navigation.

• You’ll start with HashSet basics: uniqueness, membership checks, iteration, and array conversion.
• Then move into set operations like intersection, union, and difference.
• The TreeSet exercises cover natural and custom sort order, range extraction and the navigation methods.
• The final exercises cover overriding equals() and hashCode() for custom objects, deduplicating a list, and collecting a filtered stream directly into a sorted set.

Each exercise includes a Problem Statement, Purpose, Hint, and a Solution with Explanation that clarifies exactly why each method behaves the way it does.

Exercise 1: Initialize and Append

Problem Statement: Create a HashSet of integers. Add 5 distinct numbers to it. Try adding a duplicate of one of the numbers and print the set to observe how it handles duplicates.

Purpose: This exercise demonstrates the defining trait of a Set, that it never stores duplicate elements, and shows that attempting to add one simply has no effect rather than causing an error.

Given Input: Numbers to add: 10, 20, 30, 40, 50, then a duplicate 30

Expected Output: [50, 20, 40, 10, 30] (exact printed order may vary since a HashSet does not guarantee ordering)

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        numbers.add(40);
        numbers.add(50);

        boolean wasAdded = numbers.add(30);

        System.out.println("Duplicate added: " + wasAdded);
        System.out.println(numbers);
    }
}Code language: Java (java)

Exercise 2: Verification of Existence

Problem Statement: Create a HashSet containing five different colors (Strings). Write a program to check if the color “Yellow” is present in the set.

Purpose: This exercise practices membership testing on a HashSet, which runs in constant time on average thanks to hashing, making it a much faster lookup than scanning a list one element at a time.

Given Input: colors = {"Red", "Green", "Blue", "Orange", "Purple"}

Expected Output: Contains Yellow: false

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> colors = new HashSet<>();
        colors.add("Red");
        colors.add("Green");
        colors.add("Blue");
        colors.add("Orange");
        colors.add("Purple");

        boolean hasYellow = colors.contains("Yellow");

        System.out.println("Contains Yellow: " + hasYellow);
    }
}Code language: Java (java)

Exercise 3: Iteration Techniques

Problem Statement: Add 5 elements to a HashSet. Write code to iterate through the set using two different methods: an Iterator and an enhanced for-each loop.

Purpose: This exercise practices both common ways of traversing a Set, and highlights that only the explicit Iterator supports safely removing elements while iterating.

Given Input: letters = {"A", "B", "C", "D", "E"}

Using Iterator:
A
B
C
D
E
Using for-each:
A
B
C
D
E

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

public class Main {
    public static void main(String[] args) {
        HashSet<String> letters = new HashSet<>();
        letters.add("A");
        letters.add("B");
        letters.add("C");
        letters.add("D");
        letters.add("E");

        System.out.println("Using Iterator:");
        Iterator<String> iterator = letters.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.println("Using for-each:");
        for (String letter : letters) {
            System.out.println(letter);
        }
    }
}Code language: Java (java)

Exercise 4: HashSet to Array Conversion

Problem Statement: Create a HashSet of strings and convert it into a standard Java array (String[]). Print the array elements.

Purpose: This exercise practices exporting a HashSet‘s contents into a fixed-size array, useful when passing data to an API or method that specifically expects an array rather than a Collection.

Given Input: fruits = {"Apple", "Mango", "Banana"}

Expected Output: [Apple, Mango, Banana] (exact order may vary)

import java.util.Arrays;
import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Mango");
        fruits.add("Banana");

        String[] fruitArray = fruits.toArray(new String[0]);

        System.out.println(Arrays.toString(fruitArray));
    }
}Code language: Java (java)

Exercise 5: Clear and Empty Check

Problem Statement: Write a program that populates a HashSet, checks if it is empty, clears all elements using a single method, and checks if it is empty again.

Purpose: This exercise practices resetting a set back to an empty state and verifying that state before and after, a common pattern when a collection needs to be reused across multiple operations.

Given Input: tags = {"java", "python", "sql"}

Is empty before clear: false
Is empty after clear: true

import java.util.HashSet;

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

        System.out.println("Is empty before clear: " + tags.isEmpty());

        tags.clear();

        System.out.println("Is empty after clear: " + tags.isEmpty());
    }
}Code language: Java (java)

Exercise 6: Find Common Elements (Intersection)

Problem Statement: Given two separate HashSet instances populated with numbers, write a program to find and display only the elements that exist in both sets.

Purpose: This exercise practices set intersection using the built-in retainAll() method, which mirrors the mathematical concept of a set intersection directly in code.

Given Input: setA = {1, 2, 3, 4, 5}, setB = {3, 4, 5, 6, 7}

Expected Output: [3, 4, 5] (exact printed order may vary)

import java.util.HashSet;

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

        HashSet<Integer> setB = new HashSet<>();
        setB.add(3);
        setB.add(4);
        setB.add(5);
        setB.add(6);
        setB.add(7);

        HashSet<Integer> intersection = new HashSet<>(setA);
        intersection.retainAll(setB);

        System.out.println(intersection);
    }
}Code language: Java (java)

Exercise 7: Clone a HashSet

Problem Statement: Create a HashSet of employee names. Write a program to clone this HashSet into another HashSet and verify that both contain the same elements.

Purpose: This exercise practices creating an independent copy of a set’s structure, and confirms equality between two separate set objects based on their contents rather than their identity.

Given Input: employees = {"Rahul", "Sneha", "Vikram"}

Expected Output: Sets are equal: true

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> employees = new HashSet<>();
        employees.add("Rahul");
        employees.add("Sneha");
        employees.add("Vikram");

        @SuppressWarnings("unchecked")
        HashSet<String> clonedSet = (HashSet<String>) employees.clone();

        System.out.println("Sets are equal: " + employees.equals(clonedSet));
    }
}Code language: Java (java)

Exercise 8: Natural Order Verification

Problem Statement: Create a TreeSet of integers. Insert 10 numbers in a completely random, unsorted order. Print the set to observe the automatic sorting behavior.

Purpose: This exercise introduces TreeSet, which, unlike HashSet, always keeps its elements in sorted order regardless of the sequence they were inserted in.

Given Input: Insert order: 42, 7, 19, 3, 88, 15, 61, 24, 5, 99

Expected Output: [3, 5, 7, 15, 19, 24, 42, 61, 88, 99]

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(42);
        numbers.add(7);
        numbers.add(19);
        numbers.add(3);
        numbers.add(88);
        numbers.add(15);
        numbers.add(61);
        numbers.add(24);
        numbers.add(5);
        numbers.add(99);

        System.out.println(numbers);
    }
}Code language: Java (java)

Exercise 9: Reverse Alphabetical Order

Problem Statement: Create a TreeSet that stores strings in reverse alphabetical order (Z to A) by using a custom comparator (Comparator.reverseOrder()).

Purpose: This exercise practices supplying a custom Comparator to a TreeSet‘s constructor, showing how the default natural ordering can be overridden entirely with your own comparison rule.

Given Input: Insert order: "Banana", "Apple", "Cherry", "Date"

Expected Output: [Date, Cherry, Banana, Apple]

import java.util.Comparator;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<String> fruits = new TreeSet<>(Comparator.reverseOrder());
        fruits.add("Banana");
        fruits.add("Apple");
        fruits.add("Cherry");
        fruits.add("Date");

        System.out.println(fruits);
    }
}Code language: Java (java)

Exercise 10: Fetch Extremes

Problem Statement: Write a program to find and print the lowest (first) and highest (last) elements currently stored in a TreeSet of prices.

Purpose: This exercise practices retrieving the boundary elements of a TreeSet directly, taking advantage of its sorted structure instead of scanning every element to compare values manually.

Given Input: prices = {49.99, 12.50, 89.00, 5.75, 34.20}

Lowest price: 5.75
Highest price: 89.0

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<Double> prices = new TreeSet<>();
        prices.add(49.99);
        prices.add(12.50);
        prices.add(89.00);
        prices.add(5.75);
        prices.add(34.20);

        System.out.println("Lowest price: " + prices.first());
        System.out.println("Highest price: " + prices.last());
    }
}Code language: Java (java)

Exercise 11: Destructive Polling

Problem Statement: Populate a TreeSet with numbers. Use pollFirst() and pollLast() to retrieve and remove the highest and lowest elements, then print the remaining set.

Purpose: This exercise practices combining a read and a delete into a single call, useful whenever you need to process and consume the smallest and largest elements of a set repeatedly, such as in a priority-driven task queue.

Given Input: numbers = {15, 8, 23, 4, 42, 16}

Polled first (lowest): 4
Polled last (highest): 42
Remaining set: [8, 15, 16, 23]

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(15);
        numbers.add(8);
        numbers.add(23);
        numbers.add(4);
        numbers.add(42);
        numbers.add(16);

        int lowest = numbers.pollFirst();
        int highest = numbers.pollLast();

        System.out.println("Polled first (lowest): " + lowest);
        System.out.println("Polled last (highest): " + highest);
        System.out.println("Remaining set: " + numbers);
    }
}Code language: Java (java)

Exercise 12: Head Range Selection (headSet)

Problem Statement: Given a TreeSet of integers from 1 to 10, use the headSet() method to find and print all numbers strictly less than 7.

Purpose: This exercise practices extracting a leading range of elements from a sorted set, taking advantage of the set’s structure instead of manually filtering with an if check inside a loop.

Given Input: numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Expected Output: [1, 2, 3, 4, 5, 6]

import java.util.SortedSet;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }

        SortedSet<Integer> below7 = numbers.headSet(7);

        System.out.println(below7);
    }
}Code language: Java (java)

Exercise 13: Tail Range Selection (tailSet)

Problem Statement: Given a TreeSet of exam scores, use the tailSet() method to find and print all scores that are greater than or equal to 65.

Purpose: This exercise practices extracting a trailing range of elements from a sorted set, the complementary operation to headSet(), and confirms that the boundary value itself is included.

Given Input: scores = {42, 58, 65, 71, 80, 95}

Expected Output: [65, 71, 80, 95]

import java.util.SortedSet;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<Integer> scores = new TreeSet<>();
        scores.add(42);
        scores.add(58);
        scores.add(65);
        scores.add(71);
        scores.add(80);
        scores.add(95);

        SortedSet<Integer> passingScores = scores.tailSet(65);

        System.out.println(passingScores);
    }
}Code language: Java (java)

Exercise 14: Subset Range extraction (subSet)

Problem Statement: Given a TreeSet of alphabetic characters, extract and print a subset of characters that fall between ‘C’ (inclusive) and ‘P’ (exclusive).

Purpose: This exercise practices extracting a range from both ends at once using subSet(), combining the behavior of headSet() and tailSet() into a single call.

Given Input: letters = {'A', 'C', 'F', 'K', 'P', 'T', 'Z'}

Expected Output: [C, F, K]

import java.util.SortedSet;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<Character> letters = new TreeSet<>();
        letters.add('A');
        letters.add('C');
        letters.add('F');
        letters.add('K');
        letters.add('P');
        letters.add('T');
        letters.add('Z');

        SortedSet<Character> middleRange = letters.subSet('C', 'P');

        System.out.println(middleRange);
    }
}Code language: Java (java)

Exercise 15: The Sorting Transformation

Problem Statement: Create a HashSet with unsorted city names. Convert this entire HashSet into a TreeSet and print it to show how it becomes sorted.

Purpose: This exercise practices converting between set implementations using a constructor call, the same pattern used earlier to convert a HashMap into a sorted TreeMap.

Given Input: HashSet: {"Mumbai", "Delhi", "Bangalore", "Chennai"}

Expected Output: [Bangalore, Chennai, Delhi, Mumbai]

import java.util.HashSet;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> unsortedCities = new HashSet<>();
        unsortedCities.add("Mumbai");
        unsortedCities.add("Delhi");
        unsortedCities.add("Bangalore");
        unsortedCities.add("Chennai");

        TreeSet<String> sortedCities = new TreeSet<>(unsortedCities);

        System.out.println(sortedCities);
    }
}Code language: Java (java)

Exercise 16: HashSet to ArrayList

Problem Statement: Convert a HashSet of elements into an ArrayList. Explain or demonstrate via code why you might want to switch to a List index-based retrieval.

Purpose: This exercise practices converting a Set into a List, and demonstrates a capability sets fundamentally lack, retrieving an element by its numeric position.

Given Input: tools = {"Hammer", "Wrench", "Screwdriver"}

Expected Output: Element at index 1: Wrench (exact element may vary depending on the original HashSet’s iteration order)

import java.util.ArrayList;
import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> tools = new HashSet<>();
        tools.add("Hammer");
        tools.add("Wrench");
        tools.add("Screwdriver");

        ArrayList<String> toolList = new ArrayList<>(tools);

        System.out.println("Element at index 1: " + toolList.get(1));
    }
}Code language: Java (java)

Exercise 17: Case-Insensitive TreeSet

Problem Statement: Create a TreeSet of strings that ignores case sensitivity. If “Java” is already in the set, trying to add “java” or “JAVA” should be rejected as a duplicate.

Purpose: This exercise practices supplying a custom Comparator that changes what counts as a duplicate entirely, showing that a TreeSet‘s notion of equality is fully controlled by whatever comparator it is given.

Given Input: Insert order: "Java", "java", "JAVA", "Python"

Expected Output: [Java, Python]

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<String> languages = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);

        languages.add("Java");
        languages.add("java");
        languages.add("JAVA");
        languages.add("Python");

        System.out.println(languages);
    }
}Code language: Java (java)

Exercise 18: Custom Objects in a TreeSet

Problem Statement: Create a Product class with id (int) and name (String). Implement the Comparable interface so that a TreeSet<Product> automatically sorts products by their id.

Purpose: This exercise practices implementing Comparable on a custom class, which is what allows a TreeSet to sort objects of that class without needing a separate Comparator to be supplied.

Given Input: Insert order: Product(103, "Monitor"), Product(101, "Keyboard"), Product(102, "Mouse")

Expected Output: [101 - Keyboard, 102 - Mouse, 103 - Monitor]

import java.util.TreeSet;

class Product implements Comparable<Product> {
    int id;
    String name;

    public Product(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public int compareTo(Product other) {
        return Integer.compare(this.id, other.id);
    }

    @Override
    public String toString() {
        return id + " - " + name;
    }
}

public class Main {
    public static void main(String[] args) {
        TreeSet<Product> products = new TreeSet<>();
        products.add(new Product(103, "Monitor"));
        products.add(new Product(101, "Keyboard"));
        products.add(new Product(102, "Mouse"));

        System.out.println(products);
    }
}Code language: Java (java)

Exercise 19: The Duplicate Stripper

Problem Statement: Given an ArrayList containing hundreds of duplicate user IDs, write the most concise code possible using a HashSet to completely remove the duplicates.

Purpose: This exercise practices one of the most common real-world uses of a HashSet, deduplicating a list in a single line by taking advantage of the fact that a set can never contain duplicate elements.

Given Input: userIds = [101, 102, 101, 103, 102, 101, 104]

Expected Output: Unique user IDs: 4

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> userIds = new ArrayList<>(Arrays.asList(101, 102, 101, 103, 102, 101, 104));

        HashSet<Integer> uniqueIds = new HashSet<>(userIds);

        System.out.println("Unique user IDs: " + uniqueIds.size());
    }
}Code language: Java (java)

Exercise 20: Finding Closest Match (floor and ceiling)

Problem Statement: Given a TreeSet of target scores [55, 65, 75, 85, 95], use floor() and ceiling() to find the closest matches for a query score of 80.

Purpose: This exercise practices floor() and ceiling() on a TreeSet, the set-based equivalent of the floorKey() and ceilingKey() methods explored earlier on TreeMap.

Given Input: targetScores = {55, 65, 75, 85, 95}, query = 80

Floor of 80: 75
Ceiling of 80: 85

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<Integer> targetScores = new TreeSet<>();
        targetScores.add(55);
        targetScores.add(65);
        targetScores.add(75);
        targetScores.add(85);
        targetScores.add(95);

        int query = 80;

        Integer floor = targetScores.floor(query);
        Integer ceiling = targetScores.ceiling(query);

        System.out.println("Floor of " + query + ": " + floor);
        System.out.println("Ceiling of " + query + ": " + ceiling);
    }
}Code language: Java (java)

Exercise 21: Strictly Higher/Lower (higher and lower)

Problem Statement: Given a TreeSet of auction bids, find the bid that is strictly higher than $150 and the bid strictly lower than $150 using higher() and lower().

Purpose: This exercise practices higher() and lower() on a TreeSet, which behave like ceiling() and floor() except that they always exclude an exact match, mirroring the higherKey() and lowerKey() methods seen earlier on TreeMap.

Given Input: bids = {80, 120, 150, 175, 220}, reference = 150

Lower than 150: 120
Higher than 150: 175

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<Integer> bids = new TreeSet<>();
        bids.add(80);
        bids.add(120);
        bids.add(150);
        bids.add(175);
        bids.add(220);

        int reference = 150;

        Integer lower = bids.lower(reference);
        Integer higher = bids.higher(reference);

        System.out.println("Lower than " + reference + ": " + lower);
        System.out.println("Higher than " + reference + ": " + higher);
    }
}Code language: Java (java)

Exercise 22: Mathematical Union and Difference

Problem Statement: Given two HashSet collections (Set A and Set B), write code to perform a mathematical Union (all unique elements from both) and a Difference (elements in A but not in B).

Purpose: This exercise practices two more of the standard set operations, addAll() for a union and removeAll() for a difference, rounding out the intersection operation covered in an earlier exercise.

Given Input: setA = {1, 2, 3, 4}, setB = {3, 4, 5, 6}

Union: [1, 2, 3, 4, 5, 6]
Difference (A - B): [1, 2]

import java.util.HashSet;

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

        HashSet<Integer> setB = new HashSet<>();
        setB.add(3);
        setB.add(4);
        setB.add(5);
        setB.add(6);

        HashSet<Integer> union = new HashSet<>(setA);
        union.addAll(setB);

        HashSet<Integer> difference = new HashSet<>(setA);
        difference.removeAll(setB);

        System.out.println("Union: " + union);
        System.out.println("Difference (A - B): " + difference);
    }
}Code language: Java (java)

Exercise 23: Overriding hashCode() and equals()

Problem Statement: Create a Book class with title and author. Override hashCode() and equals() so that a HashSet<Book> correctly identifies two different book objects with identical titles and authors as duplicates.

Purpose: This exercise reinforces why HashSet depends on hashCode() and equals() to detect duplicates, extending the same lesson seen earlier with HashMap keys to a set of custom objects.

Given Input: Book b1 = new Book("Dune", "Frank Herbert"); Book b2 = new Book("Dune", "Frank Herbert");

Expected Output: Set size after adding both: 1

import java.util.HashSet;
import java.util.Objects;

class Book {
    private String title;
    private String author;

    public Book(String title, String author) {
        this.title = title;
        this.author = author;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Book)) return false;
        Book other = (Book) obj;
        return title.equals(other.title) && author.equals(other.author);
    }

    @Override
    public int hashCode() {
        return Objects.hash(title, author);
    }
}

public class Main {
    public static void main(String[] args) {
        Book b1 = new Book("Dune", "Frank Herbert");
        Book b2 = new Book("Dune", "Frank Herbert");

        HashSet<Book> books = new HashSet<>();
        books.add(b1);
        books.add(b2);

        System.out.println("Set size after adding both: " + books.size());
    }
}Code language: Java (java)

Exercise 24: Unique Word Counter

Problem Statement: Write a program that takes a long paragraph of text, splits it into individual words, cleans up punctuation, and uses a Set to count exactly how many unique words were used.

Purpose: This exercise practices combining string cleanup with a Set, showing how punctuation and casing must be normalized first, or otherwise identical words would be miscounted as distinct due to trailing symbols or mismatched case.

Given Input: String text = "The fox runs. The fox jumps! Does the fox run fast, or does the fox jump far?";

Expected Output: Unique word count: 11

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        String text = "The fox runs. The fox jumps! Does the fox run fast, or does the fox jump far?";

        String[] words = text.toLowerCase().split("\\s+");
        HashSet<String> uniqueWords = new HashSet<>();

        for (String word : words) {
            String cleaned = word.replaceAll("[^a-z]", "");
            if (!cleaned.isEmpty()) {
                uniqueWords.add(cleaned);
            }
        }

        System.out.println("Unique word count: " + uniqueWords.size());
    }
}Code language: Java (java)

Exercise 25: Stream API Integration

Problem Statement: Given a HashSet of integers, use Java Streams to filter out all even numbers, square the remaining odd numbers, and collect the final results directly into a sorted TreeSet.

Purpose: This exercise practices chaining filter() and map() on a Stream built from a Set, then collecting the results directly into a different set implementation, tying together sets and Streams in a single pipeline.

Given Input: numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9}

Expected Output: [1, 9, 25, 49, 81]

import java.util.HashSet;
import java.util.TreeSet;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        for (int i = 1; i <= 9; i++) {
            numbers.add(i);
        }

        TreeSet<Integer> oddSquares = numbers.stream()
            .filter(n -> n % 2 != 0)
            .map(n -> n * n)
            .collect(Collectors.toCollection(TreeSet::new));

        System.out.println(oddSquares);
    }
}Code language: Java (java)