Collection interface in java
The `Collection` interface is the root interface of the Java Collections Framework. It represents a group of objects, known as elements, and provides a standard way to manipulate and access collections of objects. The `Collection` interface is extended by more specific subinterfaces such as `List`, `Set`, and `Queue`, each of which adds its own methods for more specific behavior.

Table of Contents
Key Characteristics:
- Basic Operations:
- The `Collection` interface defines methods for basic operations such as adding, removing, and querying elements.
- Generics:
- The `Collection` interface is generic, meaning it can hold objects of any type. The type is specified using angle brackets (<>).
```java
   Collection<String> collection = new ArrayList<>();
   ```
- No Direct Implementations:
- The `Collection` interface itself is not typically instantiated directly. Instead, concrete classes like `ArrayList`, `HashSet`, and `LinkedList` implement this interface.
Methods Defined in the Collection Interface:
The `Collection` interface includes a variety of methods that are common to all types of collections. Here are some of the most important ones:
1. Basic Operations:
- Â `boolean add(E e)`: Adds the specified element to the collection.
- `boolean remove(Object o)`: Removes a single instance of the specified element from the collection, if it is present.
- `int size()`: Returns the number of elements in the collection.
- `boolean isEmpty()`: Returns `true` if the collection contains no elements.
- `void clear()`: Removes all of the elements from the collection.
2. Query Operations:
- `boolean contains(Object o)`: Returns `true` if the collection contains the specified element.
- `boolean containsAll(Collection<?> c)`: Returns `true` if the collection contains all of the elements in the specified collection.
3. Bulk Operations:
- `boolean addAll(Collection<? extends E> c)`: Adds all of the elements in the specified collection to the collection.
- `boolean removeAll(Collection<?> c)`: Removes all of the collection’s elements that are also contained in the specified collection.
- `boolean retainAll(Collection<?> c)`: Retains only the elements in the collection that are contained in the specified collection.
4. Array Operations:
- `Object[] toArray()`: Returns an array containing all of the elements in the collection.
- `<T> T[] toArray(T[] a)`: Returns an array containing all of the elements in the collection, the runtime type of the returned array is that of the specified array.
5. Iterator:
- `Iterator<E> iterator()`: Returns an iterator over the elements in the collection.
Example of Using the Collection Interface:
Here is an example demonstrating how to use some of the methods defined in the `Collection` interface:
```java
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class CollectionExample {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
// Adding elements to the collection
collection.add("Apple");
collection.add("Banana");
collection.add("Cherry");
// Displaying the elements in the collection
System.out.println("Collection: " + collection);
// Checking if an element is in the collection
System.out.println("Contains 'Banana': " + collection.contains("Banana"));
// Iterating over the elements in the collection
System.out.print("Iterating over collection: ");
Iterator<String> iterator = collection.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
System.out.println();
// Removing an element from the collection
collection.remove("Banana");
System.out.println("After removing 'Banana': " + collection);
// Checking the size of the collection
System.out.println("Size of collection: " + collection.size());
// Clearing the collection
collection.clear();
System.out.println("Collection after clear: " + collection);
System.out.println("Is collection empty: " + collection.isEmpty());
}
}
```
Summary:
- Versatility: The `Collection` interface provides a foundation for various types of collections such as lists, sets, and queues.
- Ease of Use: Methods defined in the `Collection` interface allow for easy and consistent manipulation of collection elements.
- Extensibility: By implementing the `Collection` interface, custom collection types can be created that integrate seamlessly with the Java Collections Framework.
The `Collection` interface plays a crucial role in the Java Collections Framework by defining the standard operations that all collections must support, ensuring consistency and interoperability among different types of collections.