Set Interface in Java: Complete Guide with Implementations

Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Alice");
uniqueNames.add("Bob");
uniqueNames.add("Alice");  // This won't be added as "Alice" already exists
System.out.println(uniqueNames);  // Outputs: [Bob, Alice]

java.util.Collection (interface)
    ↑
java.util.Set (interface)
    ↑
    ├── java.util.HashSet (class)
    │       ↑
    │       └── java.util.LinkedHashSet (class)
    ├── java.util.SortedSet (interface)
    │       ↑
    │       └── java.util.NavigableSet (interface)
    │               ↑
    │               └── java.util.TreeSet (class)
    └── java.util.EnumSet (class)

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

public class HashSetDemo {
    public static void main(String[] args) {
        // Creating a HashSet
        Set<String> fruits = new HashSet<>();
        
        // Adding elements
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        fruits.add("Apple");  // Duplicate, won't be added
        
        System.out.println("HashSet: " + fruits);
        
        // Checking if an element exists
        boolean containsBanana = fruits.contains("Banana");
        System.out.println("Contains Banana? " + containsBanana);
        
        // Removing an element
        fruits.remove("Banana");
        System.out.println("After removing Banana: " + fruits);
        
        // Iterating through the set
        System.out.println("Iterating through the set:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
        
        // Size of the set
        System.out.println("Size of the set: " + fruits.size());
        
        // Checking if the set is empty
        boolean isEmpty = fruits.isEmpty();
        System.out.println("Is the set empty? " + isEmpty);
        
        // Clearing the set
        fruits.clear();
        System.out.println("After clearing: " + fruits);
        System.out.println("Is the set empty now? " + fruits.isEmpty());
    }
}

HashSet: [Apple, Cherry, Banana]
Contains Banana? true
After removing Banana: [Apple, Cherry]
Iterating through the set:
Apple
Cherry
Size of the set: 2
Is the set empty? false
After clearing: []
Is the set empty now? true

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

public class HashSetInternalsDemo {
    public static void main(String[] args) {
        // HashSet uses HashMap internally
        System.out.println("HashSet internal structure:");
        System.out.println("┌─────────────────────────────┐");
        System.out.println("│ HashMap<E, Object>          │");
        System.out.println("├─────────────────────────────┤");
        System.out.println("│ Key (element) │ Value (dummy)│");
        System.out.println("├──────────────┼──────────────┤");
        System.out.println("│ "Apple"      │ PRESENT      │");
        System.out.println("│ "Banana"     │ PRESENT      │");
        System.out.println("│ "Cherry"     │ PRESENT      │");
        System.out.println("└──────────────┴──────────────┘");
        
        Set<String> fruits = new HashSet<>();
        
        // Adding elements
        fruits.add("Apple");
        System.out.println("\nAfter adding 'Apple':");
        System.out.println("HashCode of 'Apple': " + "Apple".hashCode());
        System.out.println("Bucket index calculation: hashCode % table_size");
        
        fruits.add("Banana");
        System.out.println("\nAfter adding 'Banana':");
        System.out.println("HashCode of 'Banana': " + "Banana".hashCode());
        
        // Hash collision demonstration
        String s1 = "Aa";
        String s2 = "BB";
        System.out.println("\nHash collision example:");
        System.out.println("HashCode of 'Aa': " + s1.hashCode());
        System.out.println("HashCode of 'BB': " + s2.hashCode());
        System.out.println("These strings have the same hash code but are different!");
        System.out.println("In case of collision, elements form a linked list in the same bucket");
        
        // Performance characteristics
        System.out.println("\nPerformance characteristics:");
        System.out.println("- add(): O(1) average case, O(n) worst case");
        System.out.println("- remove(): O(1) average case, O(n) worst case");
        System.out.println("- contains(): O(1) average case, O(n) worst case");
        System.out.println("- size(): O(1)");
        
        // Memory usage
        System.out.println("\nMemory usage:");
        System.out.println("HashSet uses more memory than a simple array but provides");
        System.out.println("constant-time performance for basic operations");
    }
}

HashSet internal structure:
┌─────────────────────────────┐
│ HashMap<E, Object>          │
├─────────────────────────────┤
│ Key (element) │ Value (dummy)│
├──────────────┼──────────────┤
│ "Apple"      │ PRESENT      │
│ "Banana"     │ PRESENT      │
│ "Cherry"     │ PRESENT      │
└──────────────┴──────────────┘

After adding 'Apple':
HashCode of 'Apple': 63862674
Bucket index calculation: hashCode % table_size

After adding 'Banana':
HashCode of 'Banana': 1537083951

Hash collision example:
HashCode of 'Aa': 2112
HashCode of 'BB': 2112
These strings have the same hash code but are different!
In case of collision, elements form a linked list in the same bucket

Performance characteristics:
- add(): O(1) average case, O(n) worst case
- remove(): O(1) average case, O(n) worst case
- contains(): O(1) average case, O(n) worst case
- size(): O(1)

Memory usage:
HashSet uses more memory than a simple array but provides
constant-time performance for basic operations

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        // Creating a LinkedHashSet
        Set<String> fruits = new LinkedHashSet<>();
        
        // Adding elements
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        fruits.add("Apple");  // Duplicate, won't be added
        
        System.out.println("LinkedHashSet: " + fruits);
        
        // Note the order of elements - it's the same as insertion order
        System.out.println("Iterating through the set (maintains insertion order):");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
        
        // Removing an element
        fruits.remove("Banana");
        System.out.println("After removing Banana: " + fruits);
        
        // Adding more elements
        fruits.add("Dragonfruit");
        fruits.add("Elderberry");
        System.out.println("After adding more elements: " + fruits);
        
        // The new elements are added at the end, maintaining insertion order
        System.out.println("Iterating again to show maintained order:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
        
        // Performance characteristics
        System.out.println("\nPerformance characteristics:");
        System.out.println("- Similar to HashSet but with predictable iteration order");
        System.out.println("- Slightly slower than HashSet due to maintaining linked list");
        System.out.println("- Uses more memory than HashSet");
    }
}

LinkedHashSet: [Apple, Banana, Cherry]
Iterating through the set (maintains insertion order):
Apple
Banana
Cherry
After removing Banana: [Apple, Cherry]
After adding more elements: [Apple, Cherry, Dragonfruit, Elderberry]
Iterating again to show maintained order:
Apple
Cherry
Dragonfruit
Elderberry

Performance characteristics:
- Similar to HashSet but with predictable iteration order
- Slightly slower than HashSet due to maintaining linked list
- Uses more memory than HashSet

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetInternalsDemo {
    public static void main(String[] args) {
        // LinkedHashSet uses LinkedHashMap internally
        System.out.println("LinkedHashSet internal structure:");
        System.out.println("┌─────────────────────────────────────────────┐");
        System.out.println("│ LinkedHashMap<E, Object>                    │");
        System.out.println("├─────────────────────────────────────────────┤");
        System.out.println("│ Hash table + Doubly-linked list             │");
        System.out.println("├─────────────────────────────────────────────┤");
        System.out.println("│ Key (element) │ Value (dummy) │ Next │ Prev │");
        System.out.println("├──────────────┼──────────────┼──────┼──────┤");
        System.out.println("│ "Apple"      │ PRESENT      │  →   │  ←   │");
        System.out.println("│ "Banana"     │ PRESENT      │  →   │  ←   │");
        System.out.println("│ "Cherry"     │ PRESENT      │ null │  ←   │");
        System.out.println("└──────────────┴──────────────┴──────┴──────┘");
        
        Set<String> fruits = new LinkedHashSet<>();
        
        // Adding elements
        fruits.add("Apple");
        System.out.println("\nAfter adding 'Apple':");
        System.out.println("'Apple' is added to the hash table and linked list");
        
        fruits.add("Banana");
        System.out.println("\nAfter adding 'Banana':");
        System.out.println("'Banana' is added to the hash table and linked list");
        System.out.println("Linked list: Apple <-> Banana");
        
        fruits.add("Cherry");
        System.out.println("\nAfter adding 'Cherry':");
        System.out.println("'Cherry' is added to the hash table and linked list");
        System.out.println("Linked list: Apple <-> Banana <-> Cherry");
        
        // Removing an element
        fruits.remove("Banana");
        System.out.println("\nAfter removing 'Banana':");
        System.out.println("'Banana' is removed from the hash table and linked list");
        System.out.println("Linked list: Apple <-> Cherry");
        
        // Performance characteristics
        System.out.println("\nPerformance characteristics:");
        System.out.println("- add(): O(1) average case, O(n) worst case");
        System.out.println("- remove(): O(1) average case, O(n) worst case");
        System.out.println("- contains(): O(1) average case, O(n) worst case");
        System.out.println("- iteration: O(n) but faster than HashSet due to linked list");
        
        // Memory usage
        System.out.println("\nMemory usage:");
        System.out.println("LinkedHashSet uses more memory than HashSet due to");
        System.out.println("the additional pointers for the doubly-linked list");
        
        // Use cases
        System.out.println("\nIdeal use cases:");
        System.out.println("1. When you need both uniqueness and insertion order");
        System.out.println("2. LRU (Least Recently Used) cache implementation");
        System.out.println("3. When you need to iterate in a predictable order");
    }
}

LinkedHashSet internal structure:
┌─────────────────────────────────────────────┐
│ LinkedHashMap<E, Object>                    │
├─────────────────────────────────────────────┤
│ Hash table + Doubly-linked list             │
├─────────────────────────────────────────────┤
│ Key (element) │ Value (dummy) │ Next │ Prev │
├──────────────┼──────────────┼──────┼──────┤
│ "Apple"      │ PRESENT      │  →   │  ←   │
│ "Banana"     │ PRESENT      │  →   │  ←   │
│ "Cherry"     │ PRESENT      │ null │  ←   │
└──────────────┴──────────────┴──────┴──────┘

After adding 'Apple':
'Apple' is added to the hash table and linked list

After adding 'Banana':
'Banana' is added to the hash table and linked list
Linked list: Apple <-> Banana

After adding 'Cherry':
'Cherry' is added to the hash table and linked list
Linked list: Apple <-> Banana <-> Cherry

After removing 'Banana':
'Banana' is removed from the hash table and linked list
Linked list: Apple <-> Cherry

Performance characteristics:
- add(): O(1) average case, O(n) worst case
- remove(): O(1) average case, O(n) worst case
- contains(): O(1) average case, O(n) worst case
- iteration: O(n) but faster than HashSet due to linked list

Memory usage:
LinkedHashSet uses more memory than HashSet due to
the additional pointers for the doubly-linked list

Ideal use cases:
1. When you need both uniqueness and insertion order
2. LRU (Least Recently Used) cache implementation
3. When you need to iterate in a predictable order

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

public class TreeSetDemo {
    public static void main(String[] args) {
        // Creating a TreeSet with natural ordering
        Set<String> fruits = new TreeSet<>();
        
        // Adding elements
        fruits.add("Banana");
        fruits.add("Apple");
        fruits.add("Cherry");
        fruits.add("Apple");  // Duplicate, won't be added
        
        System.out.println("TreeSet (natural ordering): " + fruits);
        
        // Note the order of elements - it's sorted alphabetically
        System.out.println("Iterating through the set (sorted order):");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
        
        // Creating a TreeSet with custom ordering (reverse alphabetical)
        Set<String> reverseFruits = new TreeSet<>(Comparator.reverseOrder());
        reverseFruits.addAll(fruits);
        
        System.out.println("\nTreeSet (reverse ordering): " + reverseFruits);
        
        // Using TreeSet-specific methods (via casting)
        TreeSet<String> treeSet = new TreeSet<>(fruits);
        
        // First and last elements
        System.out.println("\nFirst element: " + treeSet.first());
        System.out.println("Last element: " + treeSet.last());
        
        // Subset operations
        System.out.println("\nSubset operations:");
        System.out.println("Elements less than 'Cherry': " + treeSet.headSet("Cherry"));
        System.out.println("Elements greater than or equal to 'Cherry': " + treeSet.tailSet("Cherry"));
        System.out.println("Elements between 'Apple' (inclusive) and 'Cherry' (exclusive): " + 
                          treeSet.subSet("Apple", "Cherry"));
        
        // Ceiling, floor, higher, lower
        System.out.println("\nNavigation operations:");
        System.out.println("Ceiling of 'B' (least element >= 'B'): " + treeSet.ceiling("B"));
        System.out.println("Floor of 'B' (greatest element <= 'B'): " + treeSet.floor("B"));
        System.out.println("Higher than 'Apple' (least element > 'Apple'): " + treeSet.higher("Apple"));
        System.out.println("Lower than 'Cherry' (greatest element < 'Cherry'): " + treeSet.lower("Cherry"));
        
        // Performance characteristics
        System.out.println("\nPerformance characteristics:");
        System.out.println("- add(): O(log n)");
        System.out.println("- remove(): O(log n)");
        System.out.println("- contains(): O(log n)");
        System.out.println("- first(), last(): O(log n)");
    }
}

TreeSet (natural ordering): [Apple, Banana, Cherry]
Iterating through the set (sorted order):
Apple
Banana
Cherry

TreeSet (reverse ordering): [Cherry, Banana, Apple]

First element: Apple
Last element: Cherry

Subset operations:
Elements less than 'Cherry': [Apple, Banana]
Elements greater than or equal to 'Cherry': [Cherry]
Elements between 'Apple' (inclusive) and 'Cherry' (exclusive): [Apple, Banana]

Navigation operations:
Ceiling of 'B' (least element >= 'B'): Banana
Floor of 'B' (greatest element <= 'B'): Apple
Higher than 'Apple' (least element > 'Apple'): Banana
Lower than 'Cherry' (greatest element < 'Cherry'): Banana

Performance characteristics:
- add(): O(log n)
- remove(): O(log n)
- contains(): O(log n)
- first(), last(): O(log n)

import java.util.TreeSet;

public class TreeSetInternalsDemo {
    public static void main(String[] args) {
        // TreeSet uses TreeMap internally
        System.out.println("TreeSet internal structure:");
        System.out.println("┌─────────────────────────────┐");
        System.out.println("│ Red-Black Tree              │");
        System.out.println("├─────────────────────────────┤");
        System.out.println("│         (Banana)            │");
        System.out.println("│         /      \\            │");
        System.out.println("│   (Apple)    (Cherry)       │");
        System.out.println("└─────────────────────────────┘");
        
        TreeSet<String> fruits = new TreeSet<>();
        
        // Adding elements
        fruits.add("Banana");
        System.out.println("\nAfter adding 'Banana':");
        System.out.println("Tree: Banana (root)");
        
        fruits.add("Apple");
        System.out.println("\nAfter adding 'Apple':");
        System.out.println("Tree: Banana (root)");
        System.out.println("      /");
        System.out.println("  Apple");
        
        fruits.add("Cherry");
        System.out.println("\nAfter adding 'Cherry':");
        System.out.println("Tree: Banana (root)");
        System.out.println("      /     \\");
        System.out.println("  Apple   Cherry");
        
        // Red-Black Tree properties
        System.out.println("\nRed-Black Tree properties:");
        System.out.println("1. Every node is either red or black");
        System.out.println("2. The root is black");
        System.out.println("3. All leaves (NIL) are black");
        System.out.println("4. If a node is red, both its children are black");
        System.out.println("5. Every path from root to leaves contains the same number of black nodes");
        
        // Performance characteristics
        System.out.println("\nPerformance characteristics:");
        System.out.println("- add(): O(log n)");
        System.out.println("- remove(): O(log n)");
        System.out.println("- contains(): O(log n)");
        System.out.println("- iteration: O(n) in sorted order");
        
        // Memory usage
        System.out.println("\nMemory usage:");
        System.out.println("TreeSet uses more memory than HashSet due to");
        System.out.println("storing the tree structure and balancing information");
        
        // Use cases
        System.out.println("\nIdeal use cases:");
        System.out.println("1. When you need elements in sorted order");
        System.out.println("2. When you need to find closest matches (ceiling, floor, etc.)");
        System.out.println("3. Range queries (subSet, headSet, tailSet)");
        System.out.println("4. When you need to find the smallest or largest element quickly");
    }
}

TreeSet internal structure:
┌─────────────────────────────┐
│ Red-Black Tree              │
├─────────────────────────────┤
│         (Banana)            │
│         /      \            │
│   (Apple)    (Cherry)       │
└─────────────────────────────┘

After adding 'Banana':
Tree: Banana (root)

After adding 'Apple':
Tree: Banana (root)
      /
  Apple

After adding 'Cherry':
Tree: Banana (root)
      /     \
  Apple   Cherry

Red-Black Tree properties:
1. Every node is either red or black
2. The root is black
3. All leaves (NIL) are black
4. If a node is red, both its children are black
5. Every path from root to leaves contains the same number of black nodes

Performance characteristics:
- add(): O(log n)
- remove(): O(log n)
- contains(): O(log n)
- iteration: O(n) in sorted order

Memory usage:
TreeSet uses more memory than HashSet due to
storing the tree structure and balancing information

Ideal use cases:
1. When you need elements in sorted order
2. When you need to find closest matches (ceiling, floor, etc.)
3. Range queries (subSet, headSet, tailSet)
4. When you need to find the smallest or largest element quickly

import java.util.EnumSet;
import java.util.Set;

public class EnumSetDemo {
    // Define an enum
    enum Day {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }
    
    public static void main(String[] args) {
        // Creating an empty EnumSet
        Set<Day> weekdays = EnumSet.noneOf(Day.class);
        
        // Adding elements
        weekdays.add(Day.MONDAY);
        weekdays.add(Day.TUESDAY);
        weekdays.add(Day.WEDNESDAY);
        weekdays.add(Day.THURSDAY);
        weekdays.add(Day.FRIDAY);
        
        System.out.println("Weekdays: " + weekdays);
        
        // Creating an EnumSet with all enum values
        Set<Day> allDays = EnumSet.allOf(Day.class);
        System.out.println("All days: " + allDays);
        
        // Creating an EnumSet with a range of enum values
        Set<Day> midWeek = EnumSet.range(Day.TUESDAY, Day.THURSDAY);
        System.out.println("Mid-week days: " + midWeek);
        
        // Creating an EnumSet with specific values
        Set<Day> weekend = EnumSet.of(Day.SATURDAY, Day.SUNDAY);
        System.out.println("Weekend days: " + weekend);
        
        // Set operations
        System.out.println("\nSet operations:");
        
        // Complement (all days except weekdays)
        Set<Day> notWeekdays = EnumSet.complementOf(weekdays);
        System.out.println("Not weekdays (complement): " + notWeekdays);
        
        // Union
        Set<Day> union = EnumSet.copyOf(weekdays);
        union.addAll(weekend);
        System.out.println("Weekdays ∪ Weekend (union): " + union);
        
        // Intersection
        Set<Day> intersection = EnumSet.copyOf(allDays);
        intersection.retainAll(weekdays);
        System.out.println("All days ∩ Weekdays (intersection): " + intersection);
        
        // Difference
        Set<Day> difference = EnumSet.copyOf(allDays);
        difference.removeAll(weekend);
        System.out.println("All days - Weekend (difference): " + difference);
        
        // Performance characteristics
        System.out.println("\nPerformance characteristics:");
        System.out.println("- Extremely efficient implementation for enums");
        System.out.println("- add(), remove(), contains(): O(1)");
        System.out.println("- Uses a bit vector representation internally");
        System.out.println("- Very low memory footprint");
    }
}

Weekdays: [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY]
All days: [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
Mid-week days: [TUESDAY, WEDNESDAY, THURSDAY]
Weekend days: [SATURDAY, SUNDAY]

Set operations:
Not weekdays (complement): [SATURDAY, SUNDAY]
Weekdays ∪ Weekend (union): [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
All days ∩ Weekdays (intersection): [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY]
All days - Weekend (difference): [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY]

Performance characteristics:
- Extremely efficient implementation for enums
- add(), remove(), contains(): O(1)
- Uses a bit vector representation internally
- Very low memory footprint

import java.util.EnumSet;

public class EnumSetInternalsDemo {
    enum Day {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }
    
    public static void main(String[] args) {
        // EnumSet uses a bit vector representation
        System.out.println("EnumSet internal structure:");
        System.out.println("┌─────────────────────────────┐");
        System.out.println("│ Bit Vector                  │");
        System.out.println("├─────────────────────────────┤");
        System.out.println("│ Enum Value │ Bit Position   │");
        System.out.println("├────────────┼────────────────┤");
        System.out.println("│ MONDAY     │ 0              │");
        System.out.println("│ TUESDAY    │ 1              │");
        System.out.println("│ WEDNESDAY  │ 2              │");
        System.out.println("│ THURSDAY   │ 3              │");
        System.out.println("│ FRIDAY     │ 4              │");
        System.out.println("│ SATURDAY   │ 5              │");
        System.out.println("│ SUNDAY     │ 6              │");
        System.out.println("└────────────┴────────────────┘");
        
        EnumSet<Day> weekdays = EnumSet.of(
            Day.MONDAY, Day.TUESDAY, Day.WEDNESDAY, Day.THURSDAY, Day.FRIDAY
        );
        
        System.out.println("\nWeekdays bit representation:");
        System.out.println("Binary: 0011111 (bits for FRIDAY, THURSDAY, WEDNESDAY, TUESDAY, MONDAY)");
        System.out.println("Decimal: 31");
        
        EnumSet<Day> weekend = EnumSet.of(Day.SATURDAY, Day.SUNDAY);
        
        System.out.println("\nWeekend bit representation:");
        System.out.println("Binary: 1100000 (bits for SUNDAY, SATURDAY)");
        System.out.println("Decimal: 96");
        
        // Operations as bit operations
        System.out.println("\nSet operations as bit operations:");
        System.out.println("Union: weekdays | weekend = 0011111 | 1100000 = 1111111");
        System.out.println("Intersection: weekdays & weekend = 0011111 & 1100000 = 0000000");
        System.out.println("Difference: weekdays & ~weekend = 0011111 & ~1100000 = 0011111");
        System.out.println("Complement: ~weekdays = ~0011111 = 1100000");
        
        // Performance characteristics
        System.out.println("\nPerformance characteristics:");
        System.out.println("- All operations are O(1) as they use bit manipulation");
        System.out.println("- Memory usage is optimal: only a few longs to represent all enum values");
        
        // Implementation details
        System.out.println("\nImplementation details:");
        System.out.println("- For enums with <= 64 values: RegularEnumSet (single long)");
        System.out.println("- For enums with > 64 values: JumboEnumSet (array of longs)");
        
        // Use cases
        System.out.println("\nIdeal use cases:");
        System.out.println("1. Representing flags or options (e.g., file permissions)");
        System.out.println("2. Representing states (e.g., days of week, months)");
        System.out.println("3. Any situation where you need a set of enum values");
    }
    
    }
}

EnumSet internal structure:
┌─────────────────────────────┐
│ Bit Vector                  │
├─────────────────────────────┤
│ Enum Value │ Bit Position   │
├────────────┼────────────────┤
│ MONDAY     │ 0              │
│ TUESDAY    │ 1              │
│ WEDNESDAY  │ 2              │
│ THURSDAY   │ 3              │
│ FRIDAY     │ 4              │
│ SATURDAY   │ 5              │
│ SUNDAY     │ 6              │
└────────────┴────────────────┘

Weekdays bit representation:
Binary: 0011111 (bits for FRIDAY, THURSDAY, WEDNESDAY, TUESDAY, MONDAY)
Decimal: 31

Weekend bit representation:
Binary: 1100000 (bits for SUNDAY, SATURDAY)
Decimal: 96

Set operations as bit operations:
Union: weekdays | weekend = 0011111 | 1100000 = 1111111
Intersection: weekdays & weekend = 0011111 & 1100000 = 0000000
Difference: weekdays & ~weekend = 0011111 & ~1100000 = 0011111
Complement: ~weekdays = ~0011111 = 1100000

Performance characteristics:
- All operations are O(1) as they use bit manipulation
- Memory usage is optimal: only a few longs to represent all enum values

Implementation details:
- For enums with <= 64 values: RegularEnumSet (single long)
- For enums with > 64 values: JumboEnumSet (array of longs)

Ideal use cases:
1. Representing flags or options (e.g., file permissions)
2. Representing states (e.g., days of week, months)
3. Any situation where you need a set of enum values

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

public class SetOperationsDemo {
    public static void main(String[] args) {
        // Create two sets
        Set<Integer> set1 = new HashSet<>();
        set1.add(1);
        set1.add(2);
        set1.add(3);
        set1.add(4);
        
        Set<Integer> set2 = new HashSet<>();
        set2.add(3);
        set2.add(4);
        set2.add(5);
        set2.add(6);
        
        System.out.println("Set 1: " + set1);
        System.out.println("Set 2: " + set2);
        
        // Union (addAll)
        Set<Integer> union = new HashSet<>(set1);
        union.addAll(set2);
        System.out.println("Union: " + union);
        
        // Intersection (retainAll)
        Set<Integer> intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        System.out.println("Intersection: " + intersection);
        
        // Difference (removeAll)
        Set<Integer> difference1 = new HashSet<>(set1);
        difference1.removeAll(set2);
        System.out.println("Difference (set1 - set2): " + difference1);
        
        Set<Integer> difference2 = new HashSet<>(set2);
        difference2.removeAll(set1);
        System.out.println("Difference (set2 - set1): " + difference2);
        
        // Symmetric Difference (elements in either set but not in both)
        Set<Integer> symmetricDifference = new HashSet<>(set1);
        symmetricDifference.addAll(set2);          // Union
        Set<Integer> temp = new HashSet<>(set1);
        temp.retainAll(set2);                      // Intersection
        symmetricDifference.removeAll(temp);       // Remove the intersection
        System.out.println("Symmetric Difference: " + symmetricDifference);
        
        // Subset check
        Set<Integer> subset = new HashSet<>();
        subset.add(3);
        subset.add(4);
        
        boolean isSubset = set1.containsAll(subset);
        System.out.println("Is " + subset + " a subset of " + set1 + "? " + isSubset);
        
        // Disjoint check (no common elements)
        boolean isDisjoint = !set1.stream().anyMatch(set2::contains);
        System.out.println("Are set1 and set2 disjoint? " + isDisjoint);
    }
}

Set 1: [1, 2, 3, 4]
Set 2: [3, 4, 5, 6]
Union: [1, 2, 3, 4, 5, 6]
Intersection: [3, 4]
Difference (set1 - set2): [1, 2]
Difference (set2 - set1): [5, 6]
Symmetric Difference: [1, 2, 5, 6]
Is [3, 4] a subset of [1, 2, 3, 4]? true
Are set1 and set2 disjoint? false

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

public class EqualsHashCodePitfallDemo {
    static class Person {
        private String name;
        private int age;
        
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return name + " (" + age + ")";
        }
        
        // Uncomment these methods to fix the issue
        /*
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return age == person.age && Objects.equals(name, person.name);
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
        */
    }
    
    public static void main(String[] args) {
        Set<Person> people = new HashSet<>();
        
        // Adding two "equal" persons
        people.add(new Person("John", 30));
        people.add(new Person("John", 30));
        
        System.out.println("Set size: " + people.size());
        System.out.println("People in set: " + people);
        
        System.out.println("\nProblem: Without proper equals() and hashCode() implementations,");
        System.out.println("HashSet treats these objects as different even though they represent");
        System.out.println("the same person with the same name and age.");
        
        System.out.println("\nSolution: Implement equals() and hashCode() methods to define");
        System.out.println("what makes two Person objects equal (uncomment the methods in the Person class).");
    }
}

Set size: 2
People in set: [John (30), John (30)]

Problem: Without proper equals() and hashCode() implementations,
HashSet treats these objects as different even though they represent
the same person with the same name and age.

Solution: Implement equals() and hashCode() methods to define
what makes two Person objects equal (uncomment the methods in the Person class).

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

public class ModificationPitfallDemo {
    static class MutablePerson {
        private String name;
        private int age;
        
        public MutablePerson(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        public void setName(String name) {
            this.name = name;
        }
        
        public void setAge(int age) {
            this.age = age;
        }
        
        @Override
        public String toString() {
            return name + " (" + age + ")";
        }
        
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            MutablePerson person = (MutablePerson) o;
            return age == person.age && Objects.equals(name, person.name);
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }
    
    public static void main(String[] args) {
        Set<MutablePerson> people = new HashSet<>();
        
        // Add a person to the set
        MutablePerson person = new MutablePerson("John", 30);
        people.add(person);
        
        System.out.println("Initial set: " + people);
        System.out.println("Contains John (30)? " + people.contains(new MutablePerson("John", 30)));
        
        // Modify the person after adding to the set
        person.setName("Jane");
        
        System.out.println("\nAfter modification: " + people);
        System.out.println("Contains John (30)? " + people.contains(new MutablePerson("John", 30)));
        System.out.println("Contains Jane (30)? " + people.contains(new MutablePerson("Jane", 30)));
        
        // Try to remove the modified object
        boolean removed = people.remove(person);
        System.out.println("\nRemoved Jane (30)? " + removed);
        System.out.println("Set after removal attempt: " + people);
        
        System.out.println("\nProblem: After modifying the object, its hash code changes,");
        System.out.println("so HashSet can't find it in the correct bucket anymore.");
        
        System.out.println("\nSolution: Either make objects immutable or remove them from");
        System.out.println("the set before modification and re-add them afterward.");
    }
}

Initial set: [John (30)]
Contains John (30)? true

After modification: [Jane (30)]
Contains John (30)? false
Contains Jane (30)? true

Removed Jane (30)? true
Set after removal attempt: []

Problem: After modifying the object, its hash code changes,
so HashSet can't find it in the correct bucket anymore.

Solution: Either make objects immutable or remove them from
the set before modification and re-add them afterward.

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

public class TreeSetPitfallDemo {
    static class Book {
        private String title;
        private String author;
        
        public Book(String title, String author) {
            this.title = title;
            this.author = author;
        }
        
        public String getTitle() {
            return title;
        }
        
        public String getAuthor() {
            return author;
        }
        
        @Override
        public String toString() {
            return "\"" + title + "\" by " + author;
        }
    }
    
    public static void main(String[] args) {
        try {
            // This will throw ClassCastException
            Set<Book> books = new TreeSet<>();
            books.add(new Book("1984", "George Orwell"));
            
            System.out.println("Books: " + books);
        } catch (ClassCastException e) {
            System.out.println("Error: " + e.getMessage());
            System.out.println("Book class doesn't implement Comparable interface");
        }
        
        System.out.println("\nSolution 1: Implement Comparable in the Book class");
        
        // Solution: Provide a Comparator
        System.out.println("\nSolution 2: Provide a Comparator");
        Set<Book> books = new TreeSet<>(Comparator.comparing(Book::getTitle));
        books.add(new Book("1984", "George Orwell"));
        books.add(new Book("Animal Farm", "George Orwell"));
        books.add(new Book("Brave New World", "Aldous Huxley"));
        
        System.out.println("Books sorted by title: " + books);
        
        // Another comparator
        Set<Book> booksByAuthor = new TreeSet<>(
            Comparator.comparing(Book::getAuthor)
                      .thenComparing(Book::getTitle)
        );
        booksByAuthor.addAll(books);
        
        System.out.println("Books sorted by author then title: " + booksByAuthor);
    }
}

Error: class TreeSetPitfallDemo$Book cannot be cast to class java.lang.Comparable
Book class doesn't implement Comparable interface

Solution 1: Implement Comparable in the Book class

Solution 2: Provide a Comparator
Books sorted by title: ["1984" by George Orwell, "Animal Farm" by George Orwell, "Brave New World" by Aldous Huxley]
Books sorted by author then title: ["Brave New World" by Aldous Huxley, "1984" by George Orwell, "Animal Farm" by George Orwell]

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

public class ConcurrentModificationDemo {
    public static void main(String[] args) {
        Set<String> fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        fruits.add("Date");
        
        System.out.println("Original set: " + fruits);
        
        // Incorrect way: will throw ConcurrentModificationException
        try {
            System.out.println("\nTrying to remove elements containing 'a' while iterating (incorrect way):");
            for (String fruit : fruits) {
                if (fruit.toLowerCase().contains("a")) {
                    fruits.remove(fruit);  // This will throw exception
                }
            }
        } catch (Exception e) {
            System.out.println("Error: " + e.getClass().getSimpleName());
            System.out.println("Cannot modify the set while iterating using for-each loop");
        }
        
        // Correct way 1: Using Iterator's remove method
        System.out.println("\nRemoving elements containing 'a' using Iterator (correct way 1):");
        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            if (fruit.toLowerCase().contains("a")) {
                iterator.remove();  // Safe way to remove during iteration
            }
        }
        System.out.println("Set after removal: " + fruits);
        
        // Reset the set
        fruits.clear();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        fruits.add("Date");
        
        // Correct way 2: Using removeIf (Java 8+)
        System.out.println("\nRemoving elements containing 'a' using removeIf (correct way 2):");
        fruits.removeIf(fruit -> fruit.toLowerCase().contains("a"));
        System.out.println("Set after removal: " + fruits);
    }
}

Original set: [Apple, Cherry, Banana, Date]

Trying to remove elements containing 'a' while iterating (incorrect way):
Error: ConcurrentModificationException
Cannot modify the set while iterating using for-each loop

Removing elements containing 'a' using Iterator (correct way 1):
Set after removal: [Cherry]

Removing elements containing 'a' using removeIf (correct way 2):
Set after removal: [Cherry]

import java.util.*;

public class SetSelectionDemo {
    enum Status { PENDING, PROCESSING, COMPLETED, FAILED }
    
    public static void main(String[] args) {
        // Scenario 1: Simple collection of unique strings, order doesn't matter
        System.out.println("Scenario 1: Collection of unique strings (no order requirement)");
        Set<String> uniqueWords = new HashSet<>();
        uniqueWords.add("Java");
        uniqueWords.add("Python");
        uniqueWords.add("JavaScript");
        System.out.println("HashSet: " + uniqueWords);
        System.out.println("Best choice: HashSet - O(1) operations, minimal memory overhead\n");
        
        // Scenario 2: Need to maintain insertion order
        System.out.println("Scenario 2: Need to maintain insertion order");
        Set<String> recentSearches = new LinkedHashSet<>();
        recentSearches.add("Java tutorial");
        recentSearches.add("Spring Boot example");
        recentSearches.add("Java vs Python");
        System.out.println("LinkedHashSet: " + recentSearches);
        System.out.println("Best choice: LinkedHashSet - Preserves insertion order\n");
        
        // Scenario 3: Need elements in sorted order
        System.out.println("Scenario 3: Need elements in sorted order");
        Set<String> sortedNames = new TreeSet<>();
        sortedNames.add("Charlie");
        sortedNames.add("Alice");
        sortedNames.add("Bob");
        System.out.println("TreeSet: " + sortedNames);
        System.out.println("Best choice: TreeSet - Maintains sorted order\n");
        
        // Scenario 4: Working with enum values
        System.out.println("Scenario 4: Working with enum values");
        Set<Status> activeStatuses = EnumSet.of(Status.PENDING, Status.PROCESSING);
        System.out.println("EnumSet: " + activeStatuses);
        System.out.println("Best choice: EnumSet - Most efficient for enum types\n");
        
        // Scenario 5: Need thread-safety
        System.out.println("Scenario 5: Need thread-safety");
        Set<String> concurrentSet = Collections.synchronizedSet(new HashSet<>());
        concurrentSet.add("Thread-safe element");
        System.out.println("Synchronized Set: " + concurrentSet);
        System.out.println("Best choice: Collections.synchronizedSet or ConcurrentHashMap.newKeySet()\n");
    }
}

Scenario 1: Collection of unique strings (no order requirement)
HashSet: [Java, Python, JavaScript]
Best choice: HashSet - O(1) operations, minimal memory overhead

Scenario 2: Need to maintain insertion order
LinkedHashSet: [Java tutorial, Spring Boot example, Java vs Python]
Best choice: LinkedHashSet - Preserves insertion order

Scenario 3: Need elements in sorted order
TreeSet: [Alice, Bob, Charlie]
Best choice: TreeSet - Maintains sorted order

Scenario 4: Working with enum values
EnumSet: [PENDING, PROCESSING]
Best choice: EnumSet - Most efficient for enum types

Scenario 5: Need thread-safety
Synchronized Set: [Thread-safe element]
Best choice: Collections.synchronizedSet or ConcurrentHashMap.newKeySet()

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

public class ImmutableObjectsDemo {
    // Immutable class example
    static final class ImmutablePerson {
        private final String name;
        private final int age;
        
        public ImmutablePerson(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        public String getName() {
            return name;
        }
        
        public int getAge() {
            return age;
        }
        
        // Create a new object instead of modifying
        public ImmutablePerson withName(String newName) {
            return new ImmutablePerson(newName, this.age);
        }
        
        public ImmutablePerson withAge(int newAge) {
            return new ImmutablePerson(this.name, newAge);
        }
        
        @Override
        public String toString() {
            return name + " (" + age + ")";
        }
        
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            ImmutablePerson person = (ImmutablePerson) o;
            return age == person.age && Objects.equals(name, person.name);
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }
    
    public static void main(String[] args) {
        Set<ImmutablePerson> people = new HashSet<>();
        
        // Add an immutable person
        ImmutablePerson john = new ImmutablePerson("John", 30);
        people.add(john);
        
        System.out.println("Set contains: " + people);
        
        // "Modify" by creating a new object
        ImmutablePerson johnWithNewAge = john.withAge(31);
        
        // Original object is unchanged
        System.out.println("Original object: " + john);
        System.out.println("New object: " + johnWithNewAge);
        
        // Add the new object
        people.add(johnWithNewAge);
        
        System.out.println("Set after adding modified person: " + people);
        System.out.println("Set size: " + people.size());
        
        System.out.println("\nBenefits of immutable objects with HashSet:");
        System.out.println("1. HashCode never changes, avoiding lost elements");
        System.out.println("2. Thread-safe without synchronization");
        System.out.println("3. Can be safely shared between multiple collections");
        System.out.println("4. Prevents accidental modifications");
    }
}

Set contains: [John (30)]
Original object: John (30)
New object: John (31)
Set after adding modified person: [John (30), John (31)]
Set size: 2

Benefits of immutable objects with HashSet:
1. HashCode never changes, avoiding lost elements
2. Thread-safe without synchronization
3. Can be safely shared between multiple collections
4. Prevents accidental modifications

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

public class EqualsHashCodeDemo {
    static class Product {
        private String name;
        private String category;
        private double price;
        
        public Product(String name, String category, double price) {
            this.name = name;
            this.category = category;
            this.price = price;
        }
        
        @Override
        public String toString() {
            return name + " (" + category + ", $" + price + ")";
        }
        
        // Good implementation of equals and hashCode
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Product product = (Product) o;
            return Double.compare(product.price, price) == 0 &&
                   Objects.equals(name, product.name) &&
                   Objects.equals(category, product.category);
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(name, category, price);
        }
    }
    
    static class BadProduct {
        private String name;
        private String category;
        private double price;
        
        public BadProduct(String name, String category, double price) {
            this.name = name;
            this.category = category;
            this.price = price;
        }
        
        @Override
        public String toString() {
            return name + " (" + category + ", $" + price + ")";
        }
        
        // Bad implementation - only checks name
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            BadProduct product = (BadProduct) o;
            return Objects.equals(name, product.name);
        }
        
        // Inconsistent with equals - uses all fields
        @Override
        public int hashCode() {
            return Objects.hash(name, category, price);
        }
    }
    
    public static void main(String[] args) {
        // Good implementation example
        Set<Product> products = new HashSet<>();
        products.add(new Product("Laptop", "Electronics", 999.99));
        products.add(new Product("Laptop", "Electronics", 999.99));  // Same product
        
        System.out.println("Good implementation:");
        System.out.println("Products set size: " + products.size());
        System.out.println("Products: " + products);
        
        // Bad implementation example
        Set<BadProduct> badProducts = new HashSet<>();
        badProducts.add(new BadProduct("Laptop", "Electronics", 999.99));
        badProducts.add(new BadProduct("Laptop", "Computers", 1099.99));  // Different category and price
        
        System.out.println("\nBad implementation:");
        System.out.println("BadProducts set size: " + badProducts.size());
        System.out.println("BadProducts: " + badProducts);
        
        System.out.println("\nRules for proper equals() and hashCode() implementation:");
        System.out.println("1. If two objects are equal, they MUST have the same hash code");
        System.out.println("2. If two objects have the same hash code, they are NOT necessarily equal");
        System.out.println("3. equals() should be consistent (same result for multiple calls)");
        System.out.println("4. equals() should be symmetric (a.equals(b) implies b.equals(a))");
        System.out.println("5. equals() should be transitive (a.equals(b) and b.equals(c) implies a.equals(c))");
        System.out.println("6. hashCode() should use the same fields as equals()");
        System.out.println("7. hashCode() should distribute objects evenly across buckets");
    }
}

Good implementation:
Products set size: 1
Products: [Laptop (Electronics, $999.99)]

Bad implementation:
BadProducts set size: 1
BadProducts: [Laptop (Electronics, $999.99)]

Rules for proper equals() and hashCode() implementation:
1. If two objects are equal, they MUST have the same hash code
2. If two objects have the same hash code, they are NOT necessarily equal
3. equals() should be consistent (same result for multiple calls)
4. equals() should be symmetric (a.equals(b) implies b.equals(a))
5. equals() should be transitive (a.equals(b) and b.equals(c) implies a.equals(c))
6. hashCode() should use the same fields as equals()
7. hashCode() should distribute objects evenly across buckets

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

public class SetOperationsBestPracticesDemo {
    public static void main(String[] args) {
        Set<Integer> set1 = new HashSet<>();
        set1.add(1);
        set1.add(2);
        set1.add(3);
        
        Set<Integer> set2 = new HashSet<>();
        set2.add(2);
        set2.add(3);
        set2.add(4);
        
        System.out.println("Set 1: " + set1);
        System.out.println("Set 2: " + set2);
        
        // Good practices for set operations
        
        // 1. Use addAll for union
        Set<Integer> union = new HashSet<>(set1);
        union.addAll(set2);
        System.out.println("\nUnion: " + union);
        
        // 2. Use retainAll for intersection
        Set<Integer> intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        System.out.println("Intersection: " + intersection);
        
        // 3. Use removeAll for difference
        Set<Integer> difference = new HashSet<>(set1);
        difference.removeAll(set2);
        System.out.println("Difference (set1 - set2): " + difference);
        
        // 4. Use containsAll for subset check
        boolean isSubset = set1.containsAll(intersection);
        System.out.println("Is intersection a subset of set1? " + isSubset);
        
        // 5. Use isEmpty after retainAll for disjoint check
        Set<Integer> disjointCheck = new HashSet<>(set1);
        disjointCheck.retainAll(set2);
        boolean isDisjoint = disjointCheck.isEmpty();
        System.out.println("Are set1 and set2 disjoint? " + isDisjoint);
        
        // 6. Use clear() instead of creating a new set
        Set<Integer> toBeCleared = new HashSet<>(set1);
        System.out.println("\nBefore clear: " + toBeCleared);
        toBeCleared.clear();
        System.out.println("After clear: " + toBeCleared);
        
        // 7. Use removeIf for conditional removal (Java 8+)
        Set<Integer> filtered = new HashSet<>(union);
        filtered.removeIf(n -> n % 2 == 0);  // Remove even numbers
        System.out.println("\nAfter removing even numbers: " + filtered);
        
        System.out.println("\nBest practices for Set operations:");
        System.out.println("1. Use addAll() for union");
        System.out.println("2. Use retainAll() for intersection");
        System.out.println("3. Use removeAll() for difference");
        System.out.println("4. Use containsAll() for subset check");
        System.out.println("5. Check isEmpty() after retainAll() for disjoint check");
        System.out.println("6. Use clear() to empty a set");
        System.out.println("7. Use removeIf() for conditional removal");
    }
}

Set 1: [1, 2, 3]
Set 2: [2, 3, 4]

Union: [1, 2, 3, 4]
Intersection: [2, 3]
Difference (set1 - set2): [1]
Is intersection a subset of set1? true
Are set1 and set2 disjoint? false

Before clear: [1, 2, 3]
After clear: []

After removing even numbers: [1, 3]

Best practices for Set operations:
1. Use addAll() for union
2. Use retainAll() for intersection
3. Use removeAll() for difference
4. Use containsAll() for subset check
5. Check isEmpty() after retainAll() for disjoint check
6. Use clear() to empty a set
7. Use removeIf() for conditional removal

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;

public class ThreadSafeSetDemo {
    public static void main(String[] args) {
        // Method 1: Using Collections.synchronizedSet
        Set<String> synchronizedSet = Collections.synchronizedSet(new HashSet<>());
        
        // Method 2: Using CopyOnWriteArraySet
        Set<String> copyOnWriteSet = new CopyOnWriteArraySet<>();
        
        // Method 3: Using ConcurrentHashMap.newKeySet() (Java 8+)
        Set<String> concurrentSet = ConcurrentHashMap.newKeySet();
        
        System.out.println("Thread-safe Set implementations:");
        System.out.println("1. Collections.synchronizedSet");
        System.out.println("   - Wraps any Set implementation with synchronized methods");
        System.out.println("   - Must manually synchronize when iterating");
        System.out.println("   - Good for general-purpose use with moderate contention");
        
        System.out.println("\n2. CopyOnWriteArraySet");
        System.out.println("   - Creates a new copy of the array for each modification");
        System.out.println("   - Iteration is very fast (no synchronization needed)");
        System.out.println("   - Modifications are expensive (copying the entire array)");
        System.out.println("   - Best for read-heavy, write-rare scenarios");
        
        System.out.println("\n3. ConcurrentHashMap.newKeySet()");
        System.out.println("   - Based on ConcurrentHashMap, allowing concurrent access");
        System.out.println("   - Good performance for both reads and writes");
        System.out.println("   - No synchronization needed for iteration");
        System.out.println("   - Best for general concurrent use cases");
        
        // Example of using synchronizedSet with iteration
        System.out.println("\nExample: Iterating over a synchronizedSet");
        synchronizedSet.add("Element 1");
        synchronizedSet.add("Element 2");
        
        // Correct way to iterate over a synchronizedSet
        System.out.println("Correct way (synchronized block):");
        synchronized (synchronizedSet) {
            for (String element : synchronizedSet) {
                System.out.println("  - " + element);
            }
        }
    }
}

Thread-safe Set implementations:
1. Collections.synchronizedSet
   - Wraps any Set implementation with synchronized methods
   - Must manually synchronize when iterating
   - Good for general-purpose use with moderate contention

2. CopyOnWriteArraySet
   - Creates a new copy of the array for each modification
   - Iteration is very fast (no synchronization needed)
   - Modifications are expensive (copying the entire array)
   - Best for read-heavy, write-rare scenarios

3. ConcurrentHashMap.newKeySet()
   - Based on ConcurrentHashMap, allowing concurrent access
   - Good performance for both reads and writes
   - No synchronization needed for iteration
   - Best for general concurrent use cases

Example: Iterating over a synchronizedSet
Correct way (synchronized block):
  - Element 1
  - Element 2

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class SetStreamsDemo {
    public static void main(String[] args) {
        Set<String> fruits = new HashSet<>(Arrays.asList(
            "Apple", "Banana", "Cherry", "Date", "Elderberry", "Fig"
        ));
        
        System.out.println("Original set: " + fruits);
        
        // Filtering
        Set<String> filteredFruits = fruits.stream()
            .filter(fruit -> fruit.length() > 5)
            .collect(Collectors.toSet());
        
        System.out.println("\nFruits with more than 5 letters: " + filteredFruits);
        
        // Mapping
        Set<Integer> fruitLengths = fruits.stream()
            .map(String::length)
            .collect(Collectors.toSet());
        
        System.out.println("Unique lengths of fruit names: " + fruitLengths);
        
        // Combining operations
        Set<String> processedFruits = fruits.stream()
            .filter(fruit -> fruit.contains("a") || fruit.contains("e"))
            .map(String::toUpperCase)
            .collect(Collectors.toSet());
        
        System.out.println("Uppercase fruits containing 'a' or 'e': " + processedFruits);
        
        // Creating a set from a stream
        Set<Integer> numbers = Stream.of(1, 2, 3, 4, 5, 5, 4, 3, 2, 1)
            .collect(Collectors.toSet());
        
        System.out.println("\nSet created from stream with duplicates: " + numbers);
        
        // Collecting to specific Set implementation
        LinkedHashSet<String> orderedFruits = fruits.stream()
            .sorted()
            .collect(Collectors.toCollection(LinkedHashSet::new));
        
        System.out.println("Sorted fruits in LinkedHashSet: " + orderedFruits);
        
        // Set operations with streams
        Set<String> set1 = new HashSet<>(Arrays.asList("A", "B", "C"));
        Set<String> set2 = new HashSet<>(Arrays.asList("B", "C", "D"));
        
        // Union
        Set<String> union = Stream.concat(set1.stream(), set2.stream())
            .collect(Collectors.toSet());
        
        System.out.println("\nUnion using streams: " + union);
        
        // Intersection
        Set<String> intersection = set1.stream()
            .filter(set2::contains)
            .collect(Collectors.toSet());
        
        System.out.println("Intersection using streams: " + intersection);
        
        // Difference
        Set<String> difference = set1.stream()
            .filter(element -> !set2.contains(element))
            .collect(Collectors.toSet());
        
        System.out.println("Difference using streams: " + difference);
    }
}

Original set: [Apple, Fig, Banana, Cherry, Elderberry, Date]

Fruits with more than 5 letters: [Banana, Cherry, Elderberry]
Unique lengths of fruit names: [3, 4, 5, 6, 10]
Uppercase fruits containing 'a' or 'e': [APPLE, DATE, BANANA, CHERRY, ELDERBERRY]

Set created from stream with duplicates: [1, 2, 3, 4, 5]
Sorted fruits in LinkedHashSet: [Apple, Banana, Cherry, Date, Elderberry, Fig]

Union using streams: [A, B, C, D]
Intersection using streams: [B, C]
Difference using streams: [A]

import java.util.*;

public class CustomSetDemo {
    // A simple custom Set implementation that wraps a HashSet
    // and logs all operations
    static class LoggingSet<E> implements Set<E> {
        private final Set<E> delegate;
        private final String name;
        
        public LoggingSet(String name) {
            this.delegate = new HashSet<>();
            this.name = name;
        }
        
        private void log(String operation, Object... args) {
            System.out.printf("[%s] %s: %s%n", name, operation, 
                              args.length > 0 ? Arrays.toString(args) : "");
        }
        
        @Override
        public int size() {
            int size = delegate.size();
            log("size", size);
            return size;
        }
        
        @Override
        public boolean isEmpty() {
            boolean empty = delegate.isEmpty();
            log("isEmpty", empty);
            return empty;
        }
        
        @Override
        public boolean contains(Object o) {
            boolean contains = delegate.contains(o);
            log("contains", o, contains);
            return contains;
        }
        
        @Override
        public Iterator<E> iterator() {
            log("iterator");
            return delegate.iterator();
        }
        
        @Override
        public Object[] toArray() {
            log("toArray");
            return delegate.toArray();
        }
        
        @Override
        public <T> T[] toArray(T[] a) {
            log("toArray", a);
            return delegate.toArray(a);
        }
        
        @Override
        public boolean add(E e) {
            boolean added = delegate.add(e);
            log("add", e, added);
            return added;
        }
        
        @Override
        public boolean remove(Object o) {
            boolean removed = delegate.remove(o);
            log("remove", o, removed);
            return removed;
        }
        
        @Override
        public boolean containsAll(Collection<?> c) {
            boolean containsAll = delegate.containsAll(c);
            log("containsAll", c, containsAll);
            return containsAll;
        }
        
        @Override
        public boolean addAll(Collection<? extends E> c) {
            boolean addedAll = delegate.addAll(c);
            log("addAll", c, addedAll);
            return addedAll;
        }
        
        @Override
        public boolean retainAll(Collection<?> c) {
            boolean retainedAll = delegate.retainAll(c);
            log("retainAll", c, retainedAll);
            return retainedAll;
        }
        
        @Override
        public boolean removeAll(Collection<?> c) {
            boolean removedAll = delegate.removeAll(c);
            log("removeAll", c, removedAll);
            return removedAll;
        }
        
        @Override
        public void clear() {
            log("clear");
            delegate.clear();
        }
        
        @Override
        public String toString() {
            return delegate.toString();
        }
    }
    
    public static void main(String[] args) {
        Set<String> loggingSet = new LoggingSet<>("MySet");
        
        System.out.println("Testing custom Set implementation:");
        
        loggingSet.add("Apple");
        loggingSet.add("Banana");
        
        System.out.println("Set contents: " + loggingSet);
        
        loggingSet.contains("Cherry");
        loggingSet.contains("Apple");
        
        loggingSet.remove("Banana");
        
        System.out.println("Final set: " + loggingSet);
        
        System.out.println("\nWhen to create custom Set implementations:");
        System.out.println("1. When you need to log or monitor operations");
        System.out.println("2. When you need special validation logic");
        System.out.println("3. When you need to notify listeners of changes");
        System.out.println("4. When you need to implement domain-specific behavior");
        System.out.println("5. When you need to adapt to a legacy API");
    }
}

Testing custom Set implementation:
[MySet] add: [Apple, true]
[MySet] add: [Banana, true]
Set contents: [Apple, Banana]
[MySet] contains: [Cherry, false]
[MySet] contains: [Apple, true]
[MySet] remove: [Banana, true]
Final set: [Apple]

When to create custom Set implementations:
1. When you need to log or monitor operations
2. When you need special validation logic
3. When you need to notify listeners of changes
4. When you need to implement domain-specific behavior
5. When you need to adapt to a legacy API

import java.util.*;

public class SetPerformanceDemo {
    private static final int ELEMENTS = 100_000;
    
    public static void main(String[] args) {
        // Create different set implementations
        Set<Integer> hashSet = new HashSet<>();
        Set<Integer> linkedHashSet = new LinkedHashSet<>();
        Set<Integer> treeSet = new TreeSet<>();
        
        // Measure add performance
        System.out.println("Adding " + ELEMENTS + " elements:");
        
        long start = System.nanoTime();
        for (int i = 0; i < ELEMENTS; i++) {
            hashSet.add(i);
        }
        printTime("HashSet", start);
        
        start = System.nanoTime();
        for (int i = 0; i < ELEMENTS; i++) {
            linkedHashSet.add(i);
        }
        printTime("LinkedHashSet", start);
        
        start = System.nanoTime();
        for (int i = 0; i < ELEMENTS; i++) {
            treeSet.add(i);
        }
        printTime("TreeSet", start);
        
        // Measure contains performance
        System.out.println("\nLooking up " + ELEMENTS + " elements:");
        
        start = System.nanoTime();
        for (int i = 0; i < ELEMENTS; i++) {
            hashSet.contains(i);
        }
        printTime("HashSet", start);
        
        start = System.nanoTime();
        for (int i = 0; i < ELEMENTS; i++) {
            linkedHashSet.contains(i);
        }
        printTime("LinkedHashSet", start);
        
        start = System.nanoTime();
        for (int i = 0; i < ELEMENTS; i++) {
            treeSet.contains(i);
        }
        printTime("TreeSet", start);
        
        // Measure iteration performance
        System.out.println("\nIterating over " + ELEMENTS + " elements:");
        
        start = System.nanoTime();
        for (Integer i : hashSet) {
            // Just iterate
        }
        printTime("HashSet", start);
        
        start = System.nanoTime();
        for (Integer i : linkedHashSet) {
            // Just iterate
        }
        printTime("LinkedHashSet", start);
        
        start = System.nanoTime();
        for (Integer i : treeSet) {
            // Just iterate
        }
        printTime("TreeSet", start);
        
        // Summary
        System.out.println("\nPerformance Summary:");
        System.out.println("┌────────────────┬─────────┬─────────┬─────────┐");
        System.out.println("│ Operation      │ HashSet │ LinkedHS│ TreeSet │");
        System.out.println("├────────────────┼─────────┼─────────┼─────────┤");
        System.out.println("│ add()          │ O(1)    │ O(1)    │ O(log n)│");
        System.out.println("│ remove()       │ O(1)    │ O(1)    │ O(log n)│");
        System.out.println("│ contains()     │ O(1)    │ O(1)    │ O(log n)│");
        System.out.println("│ Iteration      │ O(n)    │ O(n)    │ O(n)    │");
        System.out.println("│ Memory Usage   │ Medium  │ High    │ High    │");
        System.out.println("│ Order          │ None    │Insertion│ Sorted  │");
        System.out.println("└────────────────┴─────────┴─────────┴─────────┘");
    }
    
    private static void printTime(String implementation, long startTime) {
        long endTime = System.nanoTime();
        double milliseconds = (endTime - startTime) / 1_000_000.0;
        System.out.printf("  %s: %.2f ms%n", implementation, milliseconds);
    }
}

Adding 100000 elements:
  HashSet: 42.35 ms
  LinkedHashSet: 48.72 ms
  TreeSet: 89.14 ms

Looking up 100000 elements:
  HashSet: 18.45 ms
  LinkedHashSet: 19.32 ms
  TreeSet: 65.87 ms

Iterating over 100000 elements:
  HashSet: 5.23 ms
  LinkedHashSet: 4.18 ms
  TreeSet: 6.75 ms

Performance Summary:
┌────────────────┬─────────┬─────────┬─────────┐
│ Operation      │ HashSet │ LinkedHS│ TreeSet │
├────────────────┼─────────┼─────────┼─────────┤
│ add()          │ O(1)    │ O(1)    │ O(log n)│
│ remove()       │ O(1)    │ O(1)    │ O(log n)│
│ contains()     │ O(1)    │ O(1)    │ O(log n)│
│ Iteration      │ O(n)    │ O(n)    │ O(n)    │
│ Memory Usage   │ Medium  │ High    │ High    │
│ Order          │ None    │Insertion│ Sorted  │
└────────────────┴─────────┴─────────┴─────────┘

import java.util.*;

public class SetRealWorldExamplesDemo {
    public static void main(String[] args) {
        System.out.println("Real-world applications of Sets in Java:");
        
        // 1. Removing duplicates from a collection
        System.out.println("\n1. Removing duplicates from a list:");
        List<String> namesWithDuplicates = Arrays.asList(
            "John", "Mary", "John", "Bob", "Alice", "Mary"
        );
        System.out.println("  Original list: " + namesWithDuplicates);
        
        Set<String> uniqueNames = new HashSet<>(namesWithDuplicates);
        System.out.println("  After removing duplicates: " + uniqueNames);
        
        // 2. Checking for membership
        System.out.println("\n2. Checking for membership (e.g., user permissions):");
        Set<String> userPermissions = new HashSet<>(Arrays.asList(
            "READ", "WRITE", "DELETE"
        ));
        
        System.out.println("  User has READ permission: " + 
                          userPermissions.contains("READ"));
        System.out.println("  User has ADMIN permission: " + 
                          userPermissions.contains("ADMIN"));
        
        // 3. Finding common elements
        System.out.println("\n3. Finding common elements (e.g., friend suggestions):");
        Set<String> user1Friends = new HashSet<>(Arrays.asList(
            "Alice", "Bob", "Charlie"
        ));
        Set<String> user2Friends = new HashSet<>(Arrays.asList(
            "Bob", "Charlie", "David"
        ));
        
        Set<String> commonFriends = new HashSet<>(user1Friends);
        commonFriends.retainAll(user2Friends);
        System.out.println("  Common friends: " + commonFriends);
        
        // 4. Tracking visited elements
        System.out.println("\n4. Tracking visited elements (e.g., web crawler):");
        Set<String> visitedUrls = new HashSet<>();
        
        // Simulate crawling
        visitUrl("https://example.com", visitedUrls);
        visitUrl("https://example.com/about", visitedUrls);
        visitUrl("https://example.com", visitedUrls); // Already visited
        visitUrl("https://example.com/contact", visitedUrls);
        
        System.out.println("  Visited URLs: " + visitedUrls);
        
        // 5. Implementing mathematical sets
        System.out.println("\n5. Implementing mathematical sets:");
        Set<Integer> evenNumbers = new HashSet<>(Arrays.asList(2, 4, 6, 8, 10));
        Set<Integer> primeNumbers = new HashSet<>(Arrays.asList(2, 3, 5, 7, 11));
        
        Set<Integer> union = new HashSet<>(evenNumbers);
        union.addAll(primeNumbers);
        
        Set<Integer> intersection = new HashSet<>(evenNumbers);
        intersection.retainAll(primeNumbers);
        
        System.out.println("  Even numbers: " + evenNumbers);
        System.out.println("  Prime numbers: " + primeNumbers);
        System.out.println("  Union: " + union);
        System.out.println("  Intersection: " + intersection);
        System.out.println("  Is 2 both even and prime? " + intersection.contains(2));
        
        // 6. Implementing a cache
        System.out.println("\n6. Implementing a simple cache:");
        Set<String> cache = Collections.newSetFromMap(
            new LinkedHashMap<String, Boolean>(16, 0.75f, true) {
                @Override
                protected boolean removeEldestEntry(Map.Entry<String, Boolean> eldest) {
                    return size() > 3; // Limit cache size to 3
                }
            }
        );
        
        // Access some resources
        accessResource("resource1", cache);
        accessResource("resource2", cache);
        accessResource("resource3", cache);
        System.out.println("  Cache after accessing 3 resources: " + cache);
        
        // Access a new resource, should evict the oldest
        accessResource("resource4", cache);
        System.out.println("  Cache after accessing a 4th resource: " + cache);
        
        // Access an existing resource
        accessResource("resource2", cache);
        System.out.println("  Cache after re-accessing resource2: " + cache);
    }
    
    private static void visitUrl(String url, Set<String> visitedUrls) {
        if (visitedUrls.contains(url)) {
            System.out.println("  Already visited: " + url);
        } else {
            visitedUrls.add(url);
            System.out.println("  Visiting: " + url);
        }
    }
    
    private static void accessResource(String resource, Set<String> cache) {
        cache.add(resource);
        System.out.println("  Accessed: " + resource);
    }
}