XQA
Back to Java
2026-03-305 min read

Java HashSet

Learn Java HashSet step by step with clear examples and exercises.

Why This Matters

HashSet is a fundamental data structure in Java that provides constant-time average performance for basic operations like add(), remove(), contains(), and size(). It's an essential component of Java's Collections Framework, making it crucial for dealing with large datasets efficiently. Understanding HashSet can help you solve real-world problems, such as filtering duplicate data or performing complex queries in databases.

Prerequisites

To fully grasp this lesson, you should have a solid understanding of:

  1. Basic Java programming concepts: variables, methods, loops, and control structures.
  2. Object-oriented programming (OOP) principles: classes, objects, inheritance, and interfaces.
  3. The basics of collections in Java: List, Set, Map, and their respective implementations like ArrayList, LinkedHashSet, TreeSet, HashMap, etc.
  4. Understanding the concept of hash functions and data structures like hash tables.

Core Concept

HashSet Definition and Implementation

In Java, the HashSet class is part of the java.util package. It extends AbstractSet and implements the Set interface, ensuring that it adheres to all set operations defined by the Set interface. By default, a HashSet uses a hash table for storage, which provides constant-time average performance for basic operations.

import java.util.HashSet;

HashSet<String> myHashSet = new HashSet<>(); // Creating an empty HashSet of Strings

Adding Elements to a HashSet

To add elements to a HashSet, you can use the add() method:

myHashSet.add("Apple");
myHashSet.add("Banana");
myHashSet.add("Cherry");

Checking if an Element is Present in a HashSet

To check if an element exists in a HashSet, you can use the contains() method:

boolean isPresent = myHashSet.contains("Apple"); // Returns true

Removing Elements from a HashSet

To remove an element from a HashSet, you can use the remove() method:

myHashSet.remove("Banana");

Iterating Through a HashSet

You can iterate through a HashSet using a for-each loop or an iterator:

for (String fruit : myHashSet) {
System.out.println(fruit);
}

// Using an iterator
Iterator<String> it = myHashSet.iterator();
while (it.hasNext()) {
String fruit = it.next();
System.out.println(fruit);
}

Hash Functions and Collisions

When adding elements to a HashSet, the JVM uses a hash function to determine where in the underlying hash table each element should be stored. In ideal situations, this results in even distribution, minimizing collisions and ensuring efficient access. However, when collisions occur, the JVM uses various techniques like chaining or open addressing to handle them without significantly impacting performance.

Worked Example

Let's create a HashSet that stores the names of some programming languages and perform various set operations:

HashSet<String> programmingLanguages = new HashSet<>();
programmingLanguages.add("Java");
programmingLanguages.add("Python");
programmingLanguages.add("C++");
programmingLanguages.add("JavaScript");
programmingLanguages.add("Ruby");
programmingLanguages.add("Swift");

// Union (Combining both sets)
HashSet<String> functionalProgramming = new HashSet<>();
functionalProgramming.add("Haskell");
functionalProgramming.add("Scala");
functionalProgramming.addAll(programmingLanguages);

System.out.println("Functional and traditional programming languages: " + functionalProgramming);

// Intersection (Finding common elements)
HashSet<String> commonLanguages = new HashSet<>(programmingLanguages);
commonLanguages.retainAll(functionalProgramming);

System.out.println("Common languages between functional and traditional programming: " + commonLanguages);

// Difference (Finding elements unique to each set)
HashSet<String> traditionalOnly = new HashSet<>(programmingLanguages);
traditionalOnly.removeAll(functionalProgramming);

System.out.println("Traditional programming languages not covered by functional: " + traditionalOnly);

Common Mistakes

  1. Adding duplicate elements: Since HashSet only stores unique elements, attempting to add duplicates will have no effect.
  2. Iterating through a HashSet in reverse order: The iterator returned by HashSet.iterator() does not support traversal in reverse order. Use a List or an ArrayList if you need to iterate in reverse.
  3. Using equals() and hashCode() inconsistently: If you're using custom objects with your HashSet, make sure that the equals() method returns true when two objects are equal (i.e., have the same state) and the hashCode() method returns the same value for equal objects.
  4. Not handling null values: The default implementation of HashSet does not allow null values. If you need to store null values, consider using a HashSet with a custom null-friendly Comparator or another collection that supports null values, such as ArrayList.
  5. Ignoring hash function collisions: While the JVM handles most collisions efficiently, poorly designed hash functions can lead to excessive collisions and degraded performance. Make sure to use well-designed hash functions when working with custom objects.
  6. Using HashSet for ordered collections: HashSet does not maintain the order of its elements. If you need an ordered collection, consider using ArrayList or LinkedHashSet instead.

Practice Questions

  1. Write a program that finds the union, intersection, and difference between two HashSets containing student names.
  2. Implement a custom HashSet for storing integers that can store duplicate values.
  3. Write a program that sorts the elements of a HashSet alphabetically using a comparator.
  4. Create a HashSet containing the words from a given sentence and count the frequency of each word.
  5. Research and explain various hash function techniques used in Java's implementation of HashSet, such as chaining and open addressing.
  6. Explain how to handle collisions when using custom objects with HashSet and provide an example.
  7. What is the time complexity of basic operations in a HashSet? Discuss the best-case, average-case, and worst-case scenarios.
  8. How does Java's implementation of HashSet handle null values? Can you suggest a workaround if needed?
  9. Write a program that uses a custom Comparator to sort the elements of a HashSet based on their length.
  10. What are some common pitfalls when using HashSet, and how can they be avoided?

FAQ

  1. Why does HashSet not allow null values by default?
  • HashSet does not allow null values because it uses a hash table for storage, and null is used as a placeholder to indicate empty slots in arrays. Allowing null values would cause confusion when trying to store actual data in the set.
  1. What happens if I add duplicate elements to a HashSet?
  • Duplicate elements are automatically ignored when added to a HashSet, since it only stores unique elements.
  1. Can I sort the elements of a HashSet?
  • By default, HashSet does not provide any way to sort its elements. However, you can create a custom Comparator and use a TreeSet instead if you need to sort the elements alphabetically or numerically.
  1. What is the time complexity of basic operations in a HashSet?
  • The average time complexity for basic operations like add(), remove(), contains(), and size() is O(1), making HashSet an efficient choice for large datasets. However, the worst-case scenario can occur when the hash function produces many collisions, causing the time complexity to degrade to O(n).
Java HashSet | Java | XQA Learn