Set Interface

#Introduction

The Set interface is one of the most frequently asked topics in Java interviews. Interviewers often ask questions like:

• Why doesn't Set allow duplicates?
• How does HashSet detect duplicates?
• Difference between Set and List?
• Why must we override equals() and hashCode()?
• Which Set implementation should you choose?

Mastering the Set interface is essential before learning HashSet, LinkedHashSet and TreeSet.

#What is Set?

A Set is a collection that does not allow duplicate elements.

Package:

java.util.Set

Declaration:

public interface Set<E> extends Collection<E>

#Characteristics of Set

• No duplicate elements
• Stores unique objects
• Supports fast searching (implementation-dependent)
• Allows at most one null in most hash-based implementations
• No index-based access
• No positional methods like get()

#Real-World Analogy

Imagine a company's Employee ID system: EMP101, EMP102, EMP103, EMP101.

Can the same employee ID exist twice? No. Employee IDs must be unique. A Set works exactly like this.

#Mathematical Set Concept

Java's Set follows mathematics:

A = {1, 2, 3, 4}
B = {3, 4, 5}

Duplicate values don't exist — {1, 2, 2, 3} becomes {1, 2, 3}.

#Why Doesn't Set Allow Duplicates?

Interview favourite.

Set<Integer> set = new HashSet<>();
set.add(10);
set.add(20);
set.add(10);
System.out.println(set);

[10, 20]

The second 10 is ignored. The exact order depends on the implementation.

#How Does Set Know an Object is a Duplicate?

This is one of the most important interview questions. Java uses two methods: hashCode() and equals().

Duplicate Detection Example

String s1 = new String("Java");
String s2 = new String("Java");

Although s1 != s2, their equals() returns true. Therefore HashSet stores only one element.

#Set vs List

Interview favourite.

Why No Index?

HashSet<String> set = new HashSet<>();

Internally the elements (Java, Spring, AWS) have no guaranteed ordering. If there is no guaranteed order, there cannot be an index. Hence set.get(0) doesn't exist.

#Major Set Implementations

There are three major implementations. Each solves a different problem.

HashSet

• Uses HashMap internally
• Fastest implementation
• No ordering guarantee
• Allows one null element

Best for: fast lookup, fast insertion, fast deletion.

LinkedHashSet

• Preserves insertion order
• Uses LinkedHashMap internally
• Slightly slower than HashSet

Input 10, 30, 20 → output 10, 30, 20. Order preserved.

TreeSet

• Stores elements in sorted order
• Uses a Red-Black Tree internally
• Does not allow null elements (natural ordering)

Input 40, 10, 30, 20 → output 10, 20, 30, 40. Automatically sorted.

#Ordering in Different Sets

Interview favourite. Inserting 30, 10, 50, 20:

#Common Methods

Since Set extends Collection, it inherits all Collection methods.

Iterator<String> itr = set.iterator();
while (itr.hasNext()) {
    System.out.println(itr.next());
}

#Null Handling

Interview favourite.

set.add(null);
set.add(null);

#equals() and Set

Set<Integer> s1 = Set.of(1, 2, 3);
Set<Integer> s2 = Set.of(3, 2, 1);
s1.equals(s2);

true

Why? A Set compares elements, not order — unlike List. (Interview favourite.)

hashCode() in Set

Contract: equal sets → equal hash codes. Order doesn't matter; only elements matter.

#Performance

#Choosing the Right Set

#Real-World Use Cases

Removing duplicate values:

List<String> names = Arrays.asList("A", "B", "A", "C");

Set<String> unique = new HashSet<>(names);