Set-and-HashSet-in-Java

Below are detailed notes with code explanations for the provided Java tutorial on sets and hash sets Sets and Hash Sets in Java

1. Introduction to Sets

• Definition: Sets are part of Java's collections framework, providing a way to group like objects together. • Similarity to Lists: Operations like adding, checking containment, and removal are similar to ArrayLists.

3. Creating a Set

• Declaration: Set setName = new HashSet<>(); • Initialization: Sets cannot be directly instantiated as they are interfaces. We use implementations like HashSet. • Interface Aspect: Sets are interfaces, and you need to use a class that implements the Set interface.

5. Adding Elements to a Set

• Use add() method to add elements to the set. • Sets do not allow duplicate elements. If you try to add a duplicate, it won't be added.

7. Removing Elements from a Set

• Use remove() method to remove elements. • No direct removal by index, as sets don't maintain order. • clear() method removes all elements from the set.

9. Set Characteristics

• No Order Guarantee: Sets do not guarantee the order of elements. • No Duplicates: Sets automatically handle duplicates; attempting to add a duplicate has no effect.

11. Set Operations

• size(): Get the size of the set. • contains(element): Check if the set contains a specific element. • isEmpty(): Check if the set is empty.

13. Iterating Through a Set • Enhanced For Loop: for (Type element : set) • Lambda Expression: set.forEach(element -> System.out.println(element)); • Iterator: Using Iterator for more explicit control.

14. Use Cases for Sets

• Perfect for situations where a collection is needed without duplicates, and the order doesn't matter. • Efficient for removing duplicates from a list.

17. Other Set Implementations

18. TreeSet: • Orders elements based on their natural ordering. • Slower than HashSet but maintains order.

19. LinkedHashSet: • Maintains insertion order. • Faster than TreeSet but slower than HashSet.

Performance Considerations

• HashSet: Extremely fast for add, remove, and lookup operations (constant time). • TreeSet: Slower due to maintaining order. • LinkedHashSet: Faster than TreeSet but slower than HashSet.

18. Practical Example: Removing Duplicates from a List • Convert a list with duplicates to a set to efficiently remove duplicates.

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

public class SetExample {

public static void main(String[] args) {
    // Creating a set of strings
    Set<String> names = new HashSet<>();

    // Adding elements to the set
    names.add("Walter");
    names.add("Jesse");
    names.add("Schuyler");
    names.add("Mike");
    names.add("Saul");

    // Printing the set
    System.out.println("Initial set: " + names); // Initial set: [Mike, Jesse, Walter, Saul, Schuyler]

    // Adding a duplicate element (no effect as sets do not allow duplicates)
    names.add("Walter");

    // Printing the set after adding a duplicate
    System.out.println("Set after adding a duplicate: " + names); // Set after adding a duplicate: [Mike, Jesse, Walter, Saul, Schuyler]

    // Removing an element from the set
    names.remove("Walter");

    // Printing the set after removal
    System.out.println("Set after removing 'Walter': " + names); // Set after removing 'Walter': [Mike, Jesse, Saul, Schuyler]

    // Checking if the set contains an element
    System.out.println("Does the set contain 'Saul'? " + names.contains("Saul")); // Does the set contain 'Saul'? true

    // Getting the size of the set
    System.out.println("Size of the set: " + names.size()); // Size of the set: 4

    // Checking if the set is empty
    System.out.println("Is the set empty? " + names.isEmpty()); // Is the set empty? false

    // Clearing all elements from the set
    names.clear();

    // Printing the set after clearing
    System.out.println("Set after clearing: " + names); // Set after clearing: []

    // Adding elements to the set again
    names.add("Walter");
    names.add("Jesse");
    names.add("Schuyler");
    names.add("Mike");
    names.add("Saul");

    // Iterating through the set using an enhanced for loop
    System.out.println("Iterating through the set with an enhanced for loop:");
    for (String name : names) {
        System.out.println(name); 
        // Walter
        // Jesse
        // Schuyler
        // Mike
        // Saul
    }

    // Using a lambda expression to iterate through the set
    System.out.println("Iterating through the set with a lambda expression:");
    names.forEach(System.out::println);
    // Walter
    // Jesse
    // Schuyler
    // Mike
    // Saul

    // Using an iterator to iterate through the set
    System.out.println("Iterating through the set using an iterator:");
    java.util.Iterator<String> namesIterator = names.iterator();
    while (namesIterator.hasNext()) {
        System.out.println(namesIterator.next());
        // Walter
        // Jesse
        // Schuyler
        // Mike
        // Saul
    }

    // Creating a list with duplicates
    java.util.List<Integer> numberList = new java.util.ArrayList<>();
    numberList.add(1);
    numberList.add(2);
    numberList.add(3);
    numberList.add(2);
    numberList.add(1);

    // Creating a set to remove duplicates
    java.util.Set<Integer> numberSet = new HashSet<>(numberList);

    // Printing the set without duplicates
    System.out.println("Set without duplicates: " + numberSet); // Set without duplicates: [1, 2, 3]

    // Using a TreeSet to maintain natural ordering
    java.util.Set<String> treeSet = new java.util.TreeSet<>(names);
    System.out.println("TreeSet with natural ordering: " + treeSet); 
    // TreeSet with natural ordering: [Jesse, Mike, Saul, Schuyler, Walter]

    // Using a LinkedHashSet to maintain insertion order
    java.util.Set<String> linkedHashSet = new java.util.LinkedHashSet<>(names);
    System.out.println("LinkedHashSet with insertion order: " + linkedHashSet); 
    // LinkedHashSet with insertion order: [Walter, Jesse, Schuyler, Mike, Saul]
}

}