// Java Program to demonstrates the 
// working of AbstractSet class
import java.util.HashSet;
import java.util.Set;

abstract class AbstractSet {
    
    // Abstract method to insert an element
    public abstract void insert(int element);

    // Abstract method to display the elements
    public abstract void display();
}

class MySet extends AbstractSet {
    
    // Set to hold the elements
    private Set<Integer> elements;

    // Constructor
    public MySet() {
        elements = new HashSet<>();
    }

    // Implement the insert method
    public void insert(int element) {
        elements.add(element);
    }

    // Implement the display method
    public void display() {
        for (Integer element : elements) {
            System.out.println(element);
        }
    }
}

public class Geeks {
    public static void main(String[] args) {
        MySet s = new MySet();
        
        // Insert elements
        s.insert(10);
        s.insert(20);
        s.insert(30);
        
        // Display elements
        System.out.println("Elements in the set:");
        s.display();
    }
}

// Java program demonstrating the 
// working of a protected constructor 
// in an abstract class

// Abstract class with a protected constructor
abstract class AbstractSet {
    
    // Protected constructor, cannot be 
    // called directly from outside the class
    protected AbstractSet() {
        System.out.println("AbstractSet constructor called");
    }

    // Abstract method to be implemented by subclasses
    public abstract void display();
}

// Concrete subclass extending AbstractSet
class MySet extends AbstractSet {
    
    // Constructor for MySet
    public MySet() {
        
        // Calls the protected constructor of AbstractSet
        super();
        System.out.println("MySet constructor called");
    }

    // Implementation of the abstract display method
    @Override
    public void display() {
        System.out.println("Displaying elements in MySet");
    }
}

public class Geeks {
    public static void main(String[] args) {
        // We cannot instantiate AbstractSet directly 
        // because it is an abstract class
        // AbstractSet set = new AbstractSet(); 
        // This would cause a compile-time error

        // Creating an instance of MySet, which is a subclass of AbstractSet
        MySet set = new MySet();
        
        // Calling the display method of MySet
        set.display();
    }
}

// Java Program to Illustrate AbstractSet Class
import java.util.*;

// Concrete subclass of AbstractSet
public class Geeks {
    public static void main(String[] args) {
        
        // Creating a LinkedHashSet to 
        // maintain insertion order
        AbstractSet<Integer> set = new LinkedHashSet<>();

        // Adding elements to the AbstractSet 
        // (through LinkedHashSet)
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);
        set.add(50);

        System.out.println("AbstractSet elements: " + set);
    }
}

// Java Program to demostrates 
// the working of remove() and
// removeAll() method
import java.util.*;
public class Geeks {
    public static void main(String[] args)
    {
        // Creating a HashSet, which is a concrete subclass
        // of AbstractSet
        Set<Integer> set = new HashSet<>();

        // Adding elements to the set
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        set.add(5);

        // Printing the set before removal
        System.out.println("Set before removal(): " + set);

        // Removing a single element using remove()

        // Removes the element 3 from the set
        set.remove(3);
        System.out.println(
            "Set after removal of element 3: " + set);

        // Creating a collection to remove multiple elements
        List<Integer> l = new ArrayList<>();
        l.add(1);
        l.add(5);

        // Removing all elements in the collection using
        // removeAll() Removes all elements that are in l
        set.removeAll(l);
        System.out.println("Set after removeAll() : "
                           + set);
    }
}

// Java Program to demosntrates 
// the working of iterator()
import java.util.*;
public class Geeks{
    public static void main(String[] args) {
        
        // Creating a HashSet, which is a 
        // concrete subclass of AbstractSet
        Set<Integer> set = new HashSet<>();
        
        // Adding elements to the set
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        set.add(5);
        
        // Creating an iterator to iterate over the set
        Iterator<Integer> i = set.iterator();

        // Iterating over the elements using the iterator
        System.out.println("Iterating over the set elements:");
        while (i.hasNext()) {
            
            System.out.print(i.next() + "  ");
        }
    }
}