Sets in Java

In this tutorial, you’ll learn about Sets in Java, HashSet, Key Characteristics of HashSet, TreeSet​, Key Characteristics of TreeSet, Common Operations for HashSet and TreeSet and more along with examples.​​​​

What is Sets in Java

• A Set is an interface that extends the Collection interface in Java.
• It represents a collection of unique elements, ensuring that no duplicate elements are allowed.
• Two commonly used implementations of the Set interface are HashSet and TreeSet.

HashSet​

• A HashSet in Java is a collection that implements the Set interface from the Java Collections Framework.
• It stores unique elements and does not allow duplicates.
• HashSet uses a hash table for storage, which ensures fast access and retrieval times.

Key Characteristics of HashSet​

• Uniqueness: Stores only unique elements.
• Hash Table: Utilizes a hash table for storage, offering constant-time performance (O(1)) for basic operations like add, remove, and contains.
• Null Elements: Allows one null element.
• Order: Does not maintain any order of elements.

Declaration and Initialization​

Declaration​

To use HashSet, import it from the java.util package and declare it:

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<String> names;
    }
}

Initialization​

Initialize a HashSet using the new keyword:

names = new HashSet<>();

Combine declaration and initialization:​

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

Adding and Retrieving Elements​

Adding Elements​

Add elements to HashSet using the add() method:

names.add("Alice");
names.add("Bob");
names.add("Charlie");

Retrieving Elements​

Retrieve elements from HashSet using iteration or the contains() method:

if (names.contains("Bob")) {
    System.out.println("Bob is in the HashSet");
}

TreeSet​

• A TreeSet in Java is a collection that implements the SortedSet interface from the Java Collections Framework.
• It stores unique elements in sorted order.
• TreeSet uses a balanced tree data structure (specifically, a Red-Black tree) for storage, which maintains elements in ascending order.

Key Characteristics of TreeSet​

• Sorted Order: Maintains elements in sorted (ascending) order.
• Balanced Tree: Uses a Red-Black tree for storage, providing O(log n) time complexity for basic operations like add, remove, and contains.
• Null Elements: Does not allow null elements (throws NullPointerException).
• Performance: Offers efficient operations for accessing and manipulating elements in sorted order.

Declaration and Initialization​

Declaration​

To use TreeSet, import it from the java.util package and declare it:

import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        TreeSet<String> names;
    }
}

Initialization​

Initialize a TreeSet using the new keyword:

names = new TreeSet<>();

Combine declaration and initialization:​

TreeSet<String> names = new TreeSet<>();

Adding and Retrieving Elements​

Adding Elements​

Add elements to TreeSet using the add() method:

names.add("Alice");
names.add("Bob");
names.add("Charlie");

Retrieving Elements​

Retrieve elements from TreeSet using iteration or methods like first(), last(), lower(), higher(), etc.

String firstElement = names.first();
String lastElement = names.last();

Common Operations for HashSet and TreeSet​

Iterating Through Elements:​

for (String name : names) {
    System.out.println(name);
}

Removing Elements:​

names.remove("Bob");

Checking Set Size:​

int setSize = names.size();

Checking Existence​

boolean isCharliePresent = names.contains("Charlie");
System.out.println("Is Charlie present? " + isCharliePresent);

Key Differences​

Example: Working with Names in a HashSet:​

Let’s create a simple program that works with names stored in a HashSet:

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        // Create a HashSet to store names
        HashSet<String> names = new HashSet<>();

        // Adding elements to the HashSet
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        // Adding a duplicate element (will be ignored)
        names.add("Alice");

        // Displaying the HashSet
        System.out.println("HashSet: " + names);

        // Checking if an element exists
        if (names.contains("Bob")) {
            System.out.println("Bob is in the HashSet");
        }

        // Removing an element
        names.remove("Charlie");

        // Iterating through the HashSet
        System.out.println("Iterating through HashSet:");
        for (String name : names) {
            System.out.println(name);
        }
    }
}

Output

HashSet: [Bob, Alice, Charlie]
Bob is in the HashSet
Iterating through HashSet:
Bob
Alice

Example using TreeSet​

import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        // Create a TreeSet to store integers
        TreeSet<Integer> numbers = new TreeSet<>();

        // Adding elements to the TreeSet
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);

        // Adding a duplicate element (will be ignored)
        numbers.add(2);

        // Displaying the TreeSet (elements will be sorted automatically)
        System.out.println("TreeSet: " + numbers);

        // Checking if an element exists
        if (numbers.contains(8)) {
            System.out.println("8 is in the TreeSet");
        }

        // Removing an element
        numbers.remove(1);

        // Iterating through the TreeSet
        System.out.println("Iterating through TreeSet:");
        for (Integer num : numbers) {
            System.out.println(num);
        }
    }
}

Output

TreeSet: [1, 2, 5, 8]
8 is in the TreeSet
Iterating through TreeSet:
2
5
8