HashSet in Java credit by https://i.ytimg.com/vi/mzcrjlENnkA/maxresdefault.jpg

Mastering HashSet in Java: A Complete Guide to Unique Collections and Efficient Operations

by

What is HashSet in Java?

  • In Java, a HashSet may be a portion of the Java Collections Framework and executes the Set interface, which speaks to a collection of one of a kind components.
  • It is supported by a hash table (really a HashMap instance), and it does not allow duplicate components.
  • The essential advantage of employing a HashSet is that it offers constant-time execution (O(1)) for essential operations like adding, removing, and checking for the nearness of components, expecting the hash work scatters the elements properly among the buckets.
  • HashSet is regularly utilized after you got to store a collection of special components and perform operations like checking enrollment, eliminating duplicates, or guaranteeing that no component shows up more than once.
  • It may be a highly proficient and flexible data structure for managing sets in Java.
Hashset in Java
Hashset in Java

Key Highlights of HashSet

1.Unique Elements:
  • A HashSet does not permit duplicate values.
  • In case an attempt is made to add a duplicate component, the add operation basically returns false and does not modify the set.
2.Unordered Collection:
  • The components in a HashSet are not stored in any specific arrange.
  • After you repeat over a HashSet, the arrange of components is unpredictable.
3.Constant-Time Operations:
  • Within the normal case, the HashSet offers O(1) time complexity for add(), remove(), and contains() methods, which makes it highly proficient for managing huge collections.
4.Null Elements:
  • A HashSet can store invalid components, but as it were one invalid component can be added at most since duplicates are not permitted.
5.Does Not Ensure Order:
  • The components in a HashSet are not ordered, meaning the arrange in which components are inserted isn’t protected.
  • In case arrange things, consider employing a LinkedHashSet.

 

Types of HashSet Implementations

In Java, the HashSet class features a few varieties and related types, in spite of the fact that the class itself is ordinarily utilized straightforwardly. These types primarily contrast in how they keep up the arrange of components and their particular utilize cases.

1.HashSet:
  • Description:The default usage of the Set interface, supported by a hash table. It does not ensure any order of components.
  • Use Case:Utilized after you require a quick, unordered collection of special components.
  • Example: 

import java.util.HashSet;

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

// Add elements to the set
fruits.add(“Apple”);
fruits.add(“Banana”);
fruits.add(“Orange”);

// Try adding a duplicate element (it will be ignored)
fruits.add(“Apple”);

// Print the HashSet
System.out.println(fruits); // Output: [Apple, Banana, Orange]

// Check if an element exists
System.out.println(fruits.contains(“Apple”)); // true

// Remove an element
fruits.remove(“Banana”);
System.out.println(fruits); // Output: [Apple, Orange]
}
}

2.LinkedHashSet:
  • Description: A subclass of HashSet that keeps up the arrange of components based on their insertion order. It employments a linked list inside to preserve this arrange.
  • Use Case: Utilize when the arrange of components is vital and you still require quick set operations.
  • Example:
    import java.util.LinkedHashSet;public class LinkedHashSetExample {
    public static void main(String[] args) {
    // Create a LinkedHashSet to store String elements
    LinkedHashSet<String> cities = new LinkedHashSet<>();// Add elements to the set
    cities.add(“New York”);
    cities.add(“London”);
    cities.add(“Paris”);

    // Print the LinkedHashSet (elements will be in insertion order)
    System.out.println(cities); // Output: [New York, London, Paris]

    // Check if an element exists
    System.out.println(cities.contains(“London”)); // true

    // Remove an element
    cities.remove(“Paris”);
    System.out.println(cities); // Output: [New York, London]
    }
    }

 

3.TreeSet (Related to HashSet):

  • Description: In spite of the fact that not a coordinate subclass of HashSet, the TreeSet is frequently utilized as a variety for scenarios where components ought to be stored in a sorted arrange. It actualizes the SortedSet interface and employments a red-black tree for inner storage.
  • Use Case: Utilize once you require a set that stores components in common arrange or concurring to a indicated comparator.
  • Example: 

import java.util.TreeSet;

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

// Add elements to the set
numbers.add(10);
numbers.add(5);
numbers.add(20);

// Print the TreeSet (elements will be sorted)
System.out.println(numbers); // Output: [5, 10, 20]

// Remove an element
numbers.remove(10);
System.out.println(numbers); // Output: [5, 20]
}
}

 

Operations on HashSet

The HashSet class gives a few strategies for overseeing and controlling sets of components. Here are a few of the key operations:

1.add(E e):

  • Adds the required component to the set. In case the component is as of now display, it does not add it once more.
  • Example:

hashSet.add("Java"); // Adds "Java" to the set

 

2.remove(Object o):

  • Removes the required component from the set.
  • Example:

hashSet.remove("Java"); // Removes "Java" from the set

3.contains(Object o):

  • Checks if the set contains the required component.
  • Example:

hashSet.contains("Java"); // Returns true if "Java" is in the set

4.size():

  • Returns the number of components within the set.
  • Example:

hashSet.size(); // Returns the number of elements in the set

5.clear():

  • Removes all components from the set.
  • Example:

hashSet.clear(); // Clears the set

6.isEmpty():

  • Checks in case the set is empty.
  • Example:

hashSet.isEmpty(); // Returns true if the set is empty

 

Illustration: Working with HashSet 

import java.util.HashSet;

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

// Add elements to the HashSet
animals.add(“Lion”);
animals.add(“Tiger”);
animals.add(“Elephant”);
animals.add(“Lion”); // Duplicate, will be ignored

// Print the HashSet (order is not guaranteed)
System.out.println(animals); // Output: [Elephant, Tiger, Lion]

// Check if an element is present
if (animals.contains(“Elephant”)) {
System.out.println(“Elephant is in the set.”);
}

// Remove an element
animals.remove(“Tiger”);
System.out.println(animals); // Output: [Elephant, Lion]

// Get the size of the set
System.out.println(“Size of set: ” + animals.size()); // Output: 2
}
}

 

Performance Considerations

1.Time Complexity:

  • add(), remove(), and contains() methods for the most part have O(1) time complexity for average cases.
  • Within the worst case (due to hash collisions), these operations can degrade to O(n), but typically uncommon in case the hash function is well-designed.

2.Memory Usage:

  • Since a HashSet depends on a hash table, it may expend more memory than other collections like ArrayList.
  • In any case, the constant-time execution for operations like add() and contains() ordinarily exceeds this overhead.

Leave a Comment