AbstractSet Class in Java (original) (raw)

Last Updated : 14 Feb, 2025

In Java, the **AbstractSet class is part of the Java Collections Framework. It provides a Skeleton implementation of the set interface, which is a collection that does not allow duplicate elements. This class is abstract, meaning it cannot be instantiated directly, but it can be extended to create a custom set implementation

• AbstractSet implements the set interface but does not provide a full implementation of all set methods.
• It provides implementations for methods like size(), isEmpty() and contains()
• It requires subclasses to implement the iterator()method to define how elements are iterated over

**Example: This example demonstrates how to insert elements into a set and print them.

Java `

// 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();
}

}

`

Output

Elements in the set: 20 10 30

AbstractSet Class Hierarchy

From the below diagram, it can be concluded that it implements Iterable, Collection, Set interfaces. The direct subclasses are CopyOnWriteArraySet, EnumSet, HashSet, TreeSet.

Declaration of AbstractSet Class

In Java, the declaration of AbstractSet Class can be done as:

public abstract class AbstractSet extends AbstractCollection implements Set

Constructor

**Example: This example demonstrates how a protected constructor in an abstract class can only be called by its subclasses, and how the subclass must implement abstract methods from the abstract class.

Java `

// 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();
}

}

`

Output

AbstractSet constructor called MySet constructor called Displaying elements in MySet

Performing Various Operations on AbstractSet

**1. Adding elements: We can use add() method to insert element to a AbstractSet class.

**Example: This example demonstrates how to insert elements into an AbstractSet using a LinkedHashSet to maintain the order of insertion and display them in that order.

Java `

// 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);
}

}

`

Output

AbstractSet elements: [10, 20, 30, 40, 50]

**2. Removing Elements: We can use various methods like remove(), removeAll(), retainAll() and clear() method to remove elements from the AbstractSet.

**Example: This example demonstrates how to remove a single element using remove() and multiple elements using removeAll() from a HashSet, which a concrete subclass of AbstractSet.

Java `

// 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 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);
}

}

`

Output

Set before removal(): [1, 2, 3, 4, 5] Set after removal of element 3: [1, 2, 4, 5] Set after removeAll() : [2, 4]

**3. Iterating Elements: We can use the iterator() method to iterate over the elements of a AbstractSet.

**Example:

Java `

// 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() + "  ");
    }
}

}

`

Output

Iterating over the set elements: 1 2 3 4 5

Methods

**Methods Declared in Class java.util.AbstractCollection

Methods Declared in Interface java.util.Collection

Methods Declared in interface java.lang.Iterable

Methods Declared in interface java.util.Set

Characteristics

Some of the key characteristics of AbstractSet are listed below:

• **Implements the Set interface: AbstractSet implements the Set interface, which means that it provides a standard set of methods to manipulate sets.
• **Implements some set methods: AbstractSet implements some of the methods of the Set interface, such as size(), isEmpty(), contains(), and remove().
• **Supports iterator: AbstractSet provides an iterator method that returns an Iterator over the elements in the set.
• **Does not implement all set methods: AbstractSet is an abstract class and does not implement all the methods of the Set interface. Some of the methods that are not implemented include add(), addAll(), and clear(). These methods must be implemented by subclasses of AbstractSet.
• **Provides default implementations: AbstractSet provides default implementations for some methods of the Set interface, which can be overridden by subclasses if needed.
• **Supports null elements: AbstractSet allows null elements to be added to the set.
• **Unordered: AbstractSet is an unordered set, which means that the order in which elements are added to the set is not preserved.
• **Thread-unsafe: AbstractSet is not thread-safe, which means that if multiple threads access the same set simultaneously, it can lead to data inconsistencies. If thread safety is required, a synchronized set or a concurrent set can be used.