Collection Interface in Java

The Collection interface in Java is a core member of the Java Collections Framework located in the java.util package. It is one of the root interfaces of the Java Collection Hierarchy. The Collection interface is not directly implemented by any class. Instead, it is implemented indirectly through its sub-interfaces like List, Queue, and Set. 

For Example, the ArrayList class implements the List interface, a sub-interface of the Collection interface.

Example:

// Using the Collection interface with an ArrayList
import java.util.*;

public class Geeks {
    public static void main(String[] args) {
      
        // Create a Collection using ArrayList
        Collection<String> c = new ArrayList<>();
        
        // Adding elements to the collection
        c.add("Apple");
        c.add("Banana");
        c.add("Orange");
        
        System.out.println("Collection: " + c);
    }
}

Collection: [Apple, Banana, Orange]

Collection Interface Declaration

public interface Collection<E> extends Iterable<E>

Here, E represents the type of elements stored in the collection.

Note: In the above syntax, we can replace any class with ArrayList if that class implements the Collection interface. 

Hierarchy of Collection Interface

The Collection interface is part of a hierarchy that extends Iterable, means collections can be traversed.

The hierarchy also includes several key sub-interfaces:

• Iterable
• Collection
  • List
  • Set
  • Queue
  • Deque
  • SortedSet
  • NavigableSet

Sub-Interfaces of Collection Interface

The subInterfaces are sometimes called as Collection Types or SubTypes of Collection. These include the following:

1. List

The List interface represents an ordered collection that allows duplicates. It is implemented by classes like ArrayList, LinkedList, and Vector. Lists allow elements to be accessed by their index position.

public interface List<E> extends Collection<E>

2. Set

A set is an unordered collection of objects in which duplicate values cannot be stored. This set interface is implemented by various classes like HashSet, TreeSet, LinkedHashSet, etc.

public interface Set<E> extends Collection<E>

3. SortedSet

This interface is very similar to the set interface. The only difference is that this interface has extra methods that maintain the ordering of the elements. The sorted set interface extends the set interface and is used to handle the data which needs to be sorted. The class which implements this interface is TreeSet.

public interface SortedSet<E> extends Set<E>

4. Queue

The Queue interface represents a collection that follows FIFO (First-In-First-Out) order. It is implemented by classes like PriorityQueue, Deque, ArrayDeque, etc.

public interface Queue<E> extends Collection<E>

5. Deque

The Deque interface extends Queue and allows elements to be added or removed from both ends of the queue. It is implemented by ArrayDeque and LinkedList.

public interface Deque<E> extends Queue<E>

6. NavigableSet

The NavigableSet interface extends SortedSet and provides additional methods for navigation such as finding the closest element.

public interface NavigableSet<E> extends SortedSet<E>

Implementing Classes

• AbstractCollection
• AbstractList
• AbstractQueue
• AbstractSequentialList
• AbstractSet
• ArrayBlockingQueue
• ArrayDeque
• ArrayList
• ConcurrentLinkedDeque
• ConcurrentLinkedQueue
• ConcurrentSkipListSet
• CopyOnWriteArrayList
• CopyOnWriteArraySet
• DelayQueue
• EnumSet
• HashSet
• LinkedBlockingDeque
• LinkedBlockingQueue
• LinkedHashSet
• LinkedList
• LinkedTransferQueue
• PriorityBlockingQueue
• PriorityQueue
• Stack
• TreeSet
• Vector

Note: The Collection Interface is not limited to the above classes, there are many more classes.

Methods of Collection Interface

Method Declared in Iterable Interface:

Java Collection Interface Examples

1. Adding Elements to a Collection 

The add(E e) and addAll(Collection c) methods provided by Collection can be used to add elements. 

// Adding elements to the Collection
import java.io.*;
import java.util.*;

public class Geeks {
    public static void main(String[] args) {

        // create an empty ArrayList 
        // with an initial capacity
        Collection<Integer> l1 = new ArrayList<Integer>(5);

        // use add() method to 
        // add elements in the list
        l1.add(15);
        l1.add(20);
        l1.add(25);

        // prints all the elements available in list
        for (Integer n : l1) {
            System.out.println("Number = " + n);
        }

        // Creating another empty ArrayList
        Collection<Integer> l2 = new ArrayList<Integer>();

        // Appending the collection to the list
        l2.addAll(l1);

        // displaying the modified ArrayList
        System.out.println("The new ArrayList is: " + l2);
    }
}

Number = 15
Number = 20
Number = 25
The new ArrayList is: [15, 20, 25]

2. Removing Elements from a Collections

The remove(E e) and removeAll(Collection c) methods can be used to remove a particular element or a Collection of elements from a collection. 

// Removing elements from a Collection
import java.util.*;

public class Geeks {
    public static void main(String[] argv) throws Exception {

        // Creating object of HashSet
        Collection<Integer> hs1 = new HashSet<Integer>();

        hs1.add(1);
        hs1.add(2);
        hs1.add(3);
        hs1.add(4);
        hs1.add(5);

        System.out.println("Initial set: " + hs1);
        
          // remove a particular element
          hs1.remove(4);
      
        System.out.println("Set after removing 4: " + hs1);
      
        // Creating another object of HashSet
        Collection<Integer> hs2 = new HashSet<Integer>();
        hs2.add(1);
        hs2.add(2);
        hs2.add(3);

        System.out.println("Collection Elements to be removed: " + hs2);

        // Removing elements from hs1
        // specified in hs2
        // using removeAll() method
        hs1.removeAll(hs2);

        System.out.println("Set 1 after removeAll() operation: " + hs1);
    }
}

Initial set: [1, 2, 3, 4, 5]
Set after removing 4: [1, 2, 3, 5]
Collection Elements to be removed: [1, 2, 3]
Set 1 after removeAll() operation: [5]

3. Iterating over a Collection 

To iterate over the elements of Collection we can use iterator() method. 

// Iterating over a Collection
import java.util.*;

public class Geeks {

    public static void main(String[] args) {
      
        // Create and populate the list
        Collection<String> l = new LinkedList<>();

        l.add("Geeks");
        l.add("for");
        l.add("Geeks");

        // Displaying the list
        System.out.println("The list is:" + l);

        // Create an iterator for the list
        // using iterator() method
        Iterator<String> it = l.iterator();

        // Displaying the values after iterating
        // through the list
        System.out.println("\nThe iterator values" + " of list are: ");
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
}

The list is:[Geeks, for, Geeks]

The iterator values of list are: 
Geeks for Geeks 

G

Ganeshchowdharysadanala

Follow

Improve

Article Tags :

• Java
• Java-Collections

Practice Tags :

• Java
• Java-Collections