An In-Depth Guide to the Set Interface in Java

Set Interface

The Set interface is a part of the Java Collections Framework and is designed to represent a collection of elements where each element is unique. Unlike a List, which allows duplicate values and maintains elements in a specific order, a Set enforces uniqueness but does not guarantee any specific order of elements. The Set interface is defined in the java.util package.

Common Implementations of `Set`

When working with collections in Java, you'll often come across scenarios where you need to manage a group of elements with unique values. This is where the Set interface comes into play. In this comprehensive guide, we will explore the Set interface, its implementations, and how to use it effectively in your Java applications. Java offers several concrete implementations of the Set interface, each with its own characteristics. Let's explore some of the most commonly used ones:

HashSet:
- Uniqueness: HashSet enforces uniqueness; it automatically prevents duplicate elements.
- No Specific Order: Elements in a HashSet are not stored in any specific order. They are organized based on their hash code values, making the order unpredictable.
- Efficient Operations: HashSet offers constant-time (O(1)) average time complexity for basic operations like add, remove, and contains.
- Null Values: HashSet allows one null element to be stored.
- Not Synchronized: HashSet is not synchronized by default, meaning it is not thread-safe. If thread safety is required, consider using Collections.synchronizedSet().
- Iterating: You can iterate through the elements of a HashSet using an iterator or enhanced for loop. Keep in mind that the order of iteration is not guaranteed.
- HashSet is one of the most popular Set implementations. It uses a hash table to store elements, providing fast insertion, deletion, and retrieval operations. However, it does not maintain any specific order of elements.
LinkedHashSet:
- Uniqueness: LinkedHashSet enforces uniqueness among elements; duplicates are not allowed.
- Order Preserving: It maintains the order of insertion. When you iterate over it, elements are returned in the order they were added.
- Efficient Operations: LinkedHashSet provides efficient constant-time (O(1)) average time complexity for basic operations like add, remove, and contains.
- Null Values: LinkedHashSet allows one null element to be stored.
- Not Synchronized: LinkedHashSet is not thread-safe by default. If thread safety is needed, consider using Collections.synchronizedSet().
- Iterating: Iterating over a LinkedHashSet guarantees the order of elements, which is based on insertion order.
- LinkedHashSet is similar to HashSet but adds a linked list to maintain the order of insertion. Elements in a LinkedHashSet are stored in the order in which they were added, making it suitable for scenarios where you need to iterate through elements in a predictable order.

TreeSet:

Ordered: TreeSet maintains the elements in a specific order, making it suitable for scenarios where you need elements sorted.
Uniqueness: TreeSet enforces uniqueness; it automatically prevents duplicate elements.
Efficient Operations: TreeSet offers efficient log-time (O(log n)) time complexity for basic operations like add, remove, and contains.
Null Values: TreeSet does not allow null elements. If you need to store null, consider using a different Set implementation like HashSet.
TreeSet is a NavigableSet that uses a Red-Black tree to store elements. It offers ordered traversal of elements, either in natural order or according to a specified comparator. TreeSet is useful when you need to work with sorted sets of elements.

Creating a TreeSet with a Custom Comparator:

  import java.util.Comparator;
  import java.util.Set;
  import java.util.TreeSet;
  public class CustomComparatorExample {
      public static void main(String[] args) {
          // Create a TreeSet of Strings sorted by length
          Comparator<String> lengthComparator = Comparator.comparing(String::length);
          Set<String> treeSet = new TreeSet<>(lengthComparator);

          // Adding elements to the TreeSet
          treeSet.add("Apple");
          treeSet.add("Banana");
          treeSet.add("Cherry");

          // Printing the TreeSet
          System.out.println(treeSet); // Output: [Apple, Cherry, Banana]
      }
  }

Iterating Over a TreeSet:

You can iterate over the elements of a TreeSet using an enhanced for loop or an iterator. Elements will be returned in the sorted order.

Navigating TreeSet:

TreeSet provides methods like first(), last(), ceiling(), floor(), higher(), and lower() to navigate through the elements efficiently.

  import java.util.Set;
  import java.util.TreeSet;

  public class TreeSetNavigationExample {
      public static void main(String[] args) {
          // Create a TreeSet of Integers
          Set<Integer> treeSet = new TreeSet<>();

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

          // Using navigation methods
          System.out.println("First element: " + treeSet.first());   // Smallest element
          System.out.println("Last element: " + treeSet.last());     // Largest element
          System.out.println("Ceiling of 4: " + treeSet.ceiling(4)); // Smallest element >= 4
          System.out.println("Floor of 6: " + treeSet.floor(6));     // Largest element <= 6
          System.out.println("Higher than 2: " + treeSet.higher(2));  // Smallest element > 2
          System.out.println("Lower than 5: " + treeSet.lower(5));    // Largest element < 5
      }
  }

  /*
  first() returns the smallest (first) element in the set.
  last() returns the largest (last) element in the set.
  ceiling(4) returns the smallest element that is greater than or equal to 4.
  floor(6) returns the largest element that is less than or equal to 6.
  higher(2) returns the smallest element that is strictly greater than 2.
  lower(5) returns the largest element that is strictly less than 5.
  */
  /*
  First element: 1
  Last element: 8
  Ceiling of 4: 5
  Floor of 6: 5
  Higher than 2: 3
  Lower than 5: 3
  */

Set Operations

Sets support various set operations that you might find useful when working with collections of unique elements:

Union: Combines two sets to create a new set containing all unique elements from both sets.
Intersection: Produces a new set containing only the elements that exist in both input sets.
Difference: Creates a new set containing elements that are in one set but not in another.
Subset and Superset: You can check if one set is a subset or superset of another set.

import java.util.HashSet;
import java.util.Set;

public class SetOperationsExample {
    public static void main(String[] args) {
        // Creating two sets
        Set<Integer> setA = new HashSet<>();
        Set<Integer> setB = new HashSet<>();

        // Adding elements to setA
        setA.add(1);
        setA.add(2);
        setA.add(3);

        // Adding elements to setB
        setB.add(3);
        setB.add(4);
        setB.add(5);

        // Union: Combines two sets to create a new set containing all unique elements
        Set<Integer> unionSet = new HashSet<>(setA);
        unionSet.addAll(setB);
        System.out.println("Union Set: " + unionSet); // Output: Union Set: [1, 2, 3, 4, 5]

        // Intersection: Produces a new set containing elements that exist in both input sets
        Set<Integer> intersectionSet = new HashSet<>(setA);
        intersectionSet.retainAll(setB);
        System.out.println("Intersection Set: " + intersectionSet); // Output: Intersection Set: [3]

        // Difference: Creates a new set containing elements in setA but not in setB
        Set<Integer> differenceSet = new HashSet<>(setA);
        differenceSet.removeAll(setB);
        System.out.println("Difference Set (A - B): " + differenceSet); // Output: Difference Set (A - B): [1, 2]

        // Subset and Superset: Checking if one set is a subset or superset of another
        boolean isSubset = setA.containsAll(setB);
        boolean isSuperset = setB.containsAll(setA);

        System.out.println("Is setA a subset of setB? " + isSubset); // Output: Is setA a subset of setB? false
        System.out.println("Is setB a superset of setA? " + isSuperset); // Output: Is setB a superset of setA? false
    }
}

Below is a code where I have used some methods of Set.

package com.hk.basic;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetDemo {

    Set<Integer> hashSet;
    Set<Integer> linkedHashSet;
    Set<Integer> treeSet;

    public static void main(String[] args) {
        SetDemo demo = new SetDemo();

        //create set
        demo.hashSet = new HashSet<>();
        demo.linkedHashSet = new LinkedHashSet<>();
        demo.treeSet = new TreeSet<>();

        demo.addElement(demo);
        System.out.println("after adding\n"+demo);

        //remove element
        demo.hashSet.remove(3);        

        //check element
        System.out.println(demo.hashSet.contains(3));
        System.out.println(demo.linkedHashSet.contains(2));        

        System.out.println("after removing\n"+demo);        

        iterateSet(demo.hashSet);
        iterateSet(demo.linkedHashSet);
        iterateSet(demo.treeSet);


    }

    public static void iterateSet(Set<Integer> set) {
        System.out.println();
        for (Integer fruit : set) {
            System.out.print(fruit);
        }

        // Using an iterator
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            Integer fruit = iterator.next();
            System.out.print(fruit);
        }
    }

    public  void addElement(SetDemo demo) {
        //add element
        demo.hashSet.add(1);
        demo.hashSet.add(1);
        demo.hashSet.add(2);
        demo.hashSet.add(3);
        demo.hashSet.add(3);

        demo.linkedHashSet.add(1);
        demo.linkedHashSet.add(1);
        demo.linkedHashSet.add(2);
        demo.linkedHashSet.add(3);
        demo.linkedHashSet.add(3);

        demo.treeSet.add(1);
        demo.treeSet.add(1);
        demo.treeSet.add(2);
        demo.treeSet.add(3);
        demo.treeSet.add(3);
    }

    @Override
    public String toString() {
        return "hashSet=" + hashSet + "\nlinkedHashSet=" + linkedHashSet + "\ntreeSet=" + treeSet ;
    }
}

This is all about the Set interface, in the next blog we will learn about other implementations of the Collection Interface.

Click here to read about the Java collection framework.

Click here to read about the List Interface.

Click here to read about my most popular blog i.e. binary search.

An In-depth Guide to the Set Interface

Set Interface

Common Implementations of `Set`

Set Operations

Below is a code where I have used some methods of Set.

Subscribe to my newsletter

Hemant Besra

Hemant Besra

An In-depth Guide to the Set Interface

Set Interface

Common Implementations of Set

Set Operations

Below is a code where I have used some methods of Set.

Subscribe to my newsletter

Hemant Besra

Hemant Besra

Common Implementations of `Set`