Introduction to HashSet

A HashSet is a part of Java's Collection Framework and implements the Set interface. It is backed by a hash table (actually a HashMap instance). It does not allow duplicate elements and provides constant-time performance for basic operations like add, remove, contains, and size.

Key Characteristics of HashSet:

No Duplicates: Ensures that no duplicate elements are stored.
Unordered: Does not maintain any order of elements.
Null Elements: Allows one null element.
Not Synchronized: If multiple threads access a HashSet concurrently, and at least one of the threads modifies the set, it must be synchronized externally.

Creating a HashSet

To create a HashSet, you can use the following syntax:

HashSet<Type> setName = new HashSet<>();

Example:

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        // Creating a HashSet of Strings
        HashSet<String> fruits = new HashSet<>();

        // Adding elements to the HashSet
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        fruits.add("Mango");

        // Trying to add duplicate element
        boolean isAdded = fruits.add("Apple");

        // Displaying the HashSet
        System.out.println("HashSet: " + fruits);
        System.out.println("Was 'Apple' added again? " + isAdded);
    }
}

Explanation:

We create a HashSet named fruits.
We add several elements to the HashSet.
We attempt to add a duplicate element ("Apple") and check if it was added.
The HashSet does not allow duplicate elements, so "Apple" is not added again.

Common Methods in HashSet

Method	Description
`add(E e)`	Adds the specified element to the set if it is not already present.
`remove(Object o)`	Removes the specified element from the set if it is present.
`contains(Object o)`	Returns `true` if the set contains the specified element.
`size()`	Returns the number of elements in the set.
`isEmpty()`	Returns `true` if the set contains no elements.
`clear()`	Removes all of the elements from the set.
`iterator()`	Returns an iterator over the elements in the set.

Example:

import java.util.HashSet;

public class HashSetMethodsExample {
    public static void main(String[] args) {
        HashSet<String> fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Check if the HashSet contains a specific element
        boolean containsApple = fruits.contains("Apple");
        System.out.println("Contains 'Apple': " + containsApple);

        // Remove an element from the HashSet
        fruits.remove("Banana");
        System.out.println("After removing 'Banana': " + fruits);

        // Get the size of the HashSet
        int size = fruits.size();
        System.out.println("Size of HashSet: " + size);

        // Check if the HashSet is empty
        boolean isEmpty = fruits.isEmpty();
        System.out.println("Is HashSet empty? " + isEmpty);

        // Clear the HashSet
        fruits.clear();
        System.out.println("After clearing: " + fruits);
    }
}

Practical Exercise

Exercise 1: Basic Operations with HashSet

Task: Create a HashSet of integers and perform the following operations:

Add the numbers 1 to 10 to the HashSet.
Remove the number 5 from the HashSet.
Check if the number 7 is present in the HashSet.
Print the size of the HashSet.
Clear the HashSet and check if it is empty.

Solution:

import java.util.HashSet;

public class HashSetExercise {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();

        // Adding numbers 1 to 10
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }
        System.out.println("HashSet: " + numbers);

        // Removing number 5
        numbers.remove(5);
        System.out.println("After removing 5: " + numbers);

        // Checking if number 7 is present
        boolean containsSeven = numbers.contains(7);
        System.out.println("Contains 7: " + containsSeven);

        // Printing the size of the HashSet
        int size = numbers.size();
        System.out.println("Size of HashSet: " + size);

        // Clearing the HashSet
        numbers.clear();
        System.out.println("After clearing: " + numbers);

        // Checking if the HashSet is empty
        boolean isEmpty = numbers.isEmpty();
        System.out.println("Is HashSet empty? " + isEmpty);
    }
}

Common Mistakes and Tips

Duplicate Elements: Remember that HashSet does not allow duplicate elements. If you try to add a duplicate, it will not be added, and the add method will return false.
Order of Elements: Do not rely on the order of elements in a HashSet. If you need a specific order, consider using a LinkedHashSet or TreeSet.
Null Elements: While HashSet allows one null element, be cautious when working with nulls, especially in a multi-threaded environment.

Conclusion

In this section, you learned about the HashSet class in Java, its key characteristics, and how to perform basic operations. You also practiced using HashSet through a practical exercise. Understanding HashSet is crucial for efficiently managing collections of unique elements in Java. In the next section, we will explore other important data structures in Java's Collection Framework.

HashSet

Introduction to HashSet

Key Characteristics of HashSet:

Creating a HashSet

Example:

Explanation:

Common Methods in HashSet

Example:

Practical Exercise

Exercise 1: Basic Operations with HashSet

Common Mistakes and Tips

Conclusion

Java Programming Course

Module 1: Introduction to Java

Module 2: Control Flow

Module 3: Object-Oriented Programming

Module 4: Advanced Object-Oriented Programming

Module 5: Data Structures and Collections

Module 6: Exception Handling

Module 7: File I/O

Module 8: Multithreading and Concurrency

Module 9: Networking

Module 10: Advanced Topics

Module 11: Java Frameworks and Libraries

Module 12: Building Real-World Applications