Collection Interface in Java

The Collection interface is the root of the Java Collections Framework, defined in the java.util package. It represents a group of individual objects as a single unit and provides basic operations for working with them.

• Represents a group of objects as a single unit
• Dynamic in size (can grow or shrink)
• Provide simple methods like add(), remove(), and clear().
• Stores elements of a specific type using generics

Declaration

public interface Collection<E> extends Iterable<E>

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

Object Creation of Collection Interface

Collection<String> fruits = new ArrayList<>();

After Removal: [Apple, Mango]

In Java, we cannot create an object of an interface directly. Instead, we create an object of the ArrayList class that implements the interface and assign it to the interface reference.

Hierarchy of Collection Interface

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

Sub-Interfaces of Collection Interface

The sub-interfaces of Collection, also called collection types, are:

1. List

• List represents an ordered collection that allows duplicates.
• Elements can be accessed by index.
• Implementing Classes: ArrayList, LinkedList, Vector, Stack.

Declaration:

public interface List<E> extends Collection<E>

2. Set

• Set represents an unordered collection with no duplicate elements.
• Implementing Classes: HashSet, TreeSet, LinkedHashSet, EnumSet, CopyOnWriteArraySet.

Declaration:

public interface Set<E> extends Collection<E>

3. SortedSet

• SortedSet extends Set and maintains elements in a sorted order.
• Provides methods to handle range-based operations.
• Implementing Class: TreeSet.

Declaration:

public interface SortedSet<E> extends Set<E>

4. NavigableSet

• NavigableSet extends SortedSet and provides navigation methods like lower(), floor(), ceiling(), and higher().
• Implementing Class: TreeSet.

Declaration:

public interface NavigableSet<E> extends SortedSet<E>

5. Queue

• Queue represents a collection following FIFO (First-In-First-Out) order.
• Implementing Classes: PriorityQueue, ArrayDeque, LinkedList.

Declaration:

public interface Queue<E> extends Collection<E>

6. Deque

• Deque extends Queue and allows elements to be added/removed from both ends.
• Implementing Classes: ArrayDeque, LinkedList.

Declaration:

public interface Deque<E> extends Queue<E>

Operations on Collection Objects

The Collection interface provides several operations to manipulate data efficiently. Let’s see the most common operations using the ArrayList implementation class.

1. Adding Elements

We can add elements using the add(E e) method for a single element or addAll(Collection c) to add multiple elements.

After adding elements: [10, 20, 30, 40, 50]

2. Removing Elements

Elements can be removed using remove(E e) or removeAll(Collection c) methods. 

Initial Collection: [Apple, Banana, Mango, Orange]
After removing Mango: [Apple, Banana, Orange]
After removeAll(): [Orange]

3. Accessing Elements

Although the Collection interface doesn’t provide index-based access, its sub-interface List (implemented by ArrayList) allows retrieving elements using the get(int index) method.

Colors List: [Red, Green, Blue]
First Color: Red
Last Color: Blue

4. Iterating over a Collection 

To iterate over a collection we used Different types of cursor

1. Iterator

• The Iterator interface allows traversal in one direction (forward).
• You can safely remove elements during iteration using remove().

[Apple, Mango]

2. ListIterator

• ListIterator extends Iterator and is available for List implementations (ArrayList, LinkedList, etc.).
• Supports bidirectional traversal (forward and backward).
• Allows adding, removing, and replacing elements during iteration.

Forward: Red Green Blue 
Backward: Blue Green Red 

Removing During Iteration

• Using Iterator.remove() or ListIterator.remove() is the correct way to remove elements while iterating.
• Directly using collection.remove(element) inside a loop will throw ConcurrentModificationException.

Methods of Collection Interface

Note:

• equals() determines if two elements are logically equal.
• hashCode() provides a hash value for efficient storage and lookup (especially in sets and hash-based collections).