Collections Class in Java

The Collections class in Java is a utility class provided by the Java Collections Framework that contains static methods for performing common operations on collections. It simplifies tasks like sorting, searching, and modifying collection elements efficiently.

• Provides methods such as sort(), reverse(), shuffle(), and binarySearch()
• Helps improve code readability and performance without manual implementation

import java.util.ArrayList;

public class Geeks {
    public static void main(String[] args) {
      
        // Create an ArrayList to store elements
        ArrayList<String> al = new ArrayList<>();
        
        // Add elements to the list
        al.add("Apple");
        al.add("Banana");
        al.add("Apple"); // Duplicates are allowed

        System.out.println("" + al);
    }
}

[Apple, Banana, Apple]

Explanation: An ArrayList of type String is created and elements are added to it, including a duplicate value. The output shows that ArrayList maintains insertion order and allows duplicate elements.

Collection Class Declaration

public class Collections extends Object

Object is the parent class of all the classes.

Java Collections Classes

Collection Framework contains both classes and interfaces. Although both seem the same but there are certain differences between Collection classes and the Collections framework.

To know more about ->Collection vs Collections

The Collection classes in Java are mentioned below:

1. List Implemented Classes

Lists are ordered collections that allow duplicates.

• ArrayList: A resizable array that maintains insertion order. Allows duplicates and provides fast random access.
• LinkedList: Implements a doubly-linked list. Can be used as List, Stack, or Queue.
• Vector: Synchronized resizable array. Slower than ArrayList but thread-safe.
• Stack: Extends Vector. Follows LIFO (Last-In-First-Out) principle for storing elements.

2. Set Implemented Classes

Sets are unordered collections that do not allow duplicates.

• HashSet: Stores elements in a hash table. Offers fast insertion, deletion, and search.
• LinkedHashSet: Maintains insertion order using a doubly-linked list internally.
• TreeSet: Stores elements in sorted order. Implements SortedSet and ensures natural or custom ordering.

3. Queue Implemented Classes

Queues hold elements prior to processing, typically following FIFO, but can support priority.

• PriorityQueue: Orders elements based on priority or a custom comparator.
• ArrayDeque: Double-ended queue using a resizable array. Can function as a stack or queue.
• LinkedList: Can also be used as a Queue. Maintains insertion order and allows duplicates

4. Map Implemented Classes

Maps store key-value pairs with unique keys. Not part of the Collection interface but part of JCF.

• HashMap: Stores key-value pairs with fast access. Allows one null key and multiple null values.
• LinkedHashMap: Maintains insertion order of keys.
• TreeMap: Keys are sorted either naturally or with a custom comparator.
• Hashtable: Synchronized map. Does not allow null keys or null values.
• EnumMap: Specialized map for enum keys. Efficient storage and fast access.
• WeakHashMap: Uses weak references for keys. Unreferenced keys can be garbage collected.
• IdentityHashMap: Uses reference equality (==) instead of equals() for key comparison.
• ConcurrentHashMap: Thread-safe map optimized for concurrent access by multiple threads.

5. Abstract Base Classes

These classes provide common functionalities and simplify implementation of concrete collection classes.

• AbstractCollection: Base class for implementing custom collections.
• AbstractList: Base class for List implementations. Provides default methods for lists.
• AbstractSet: Base class for Set implementations. Provides default methods for sets.
• AbstractMap: Base class for Map implementations. Simplifies map creation.
• AbstractQueue: Base class for Queue implementations. Provides basic queue operations.

Examples of Collections Operations

1. Adding Elements

import java.util.ArrayList;
import java.util.Collections;

public class AddExample {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        Collections.addAll(list, "Mango", "Grapes");
        System.out.println("After Adding: " + list);
    }
}

After Adding: [Apple, Banana, Mango, Grapes]

Explanation

• Creates an ArrayList to store String elements dynamically.
• Adds elements using add() and multiple elements at once using Collections.addAll().
• Maintains insertion order and allows duplicates.

2. Deleting Elements

import java.util.ArrayList;

public class GFG {
    public static void main(String[] args) {
        
        ArrayList<String> list = new ArrayList<>();
        
        // Adding elements
        list.add("Apple");
        list.add("Banana");
        list.add("Mango");
        list.add("Grapes");

        // Remove element by value
        list.remove("Banana");

        // Remove element by index
        list.remove(0);

        // Print final list
        System.out.println("After Removing: " + list);
    }
}

After Removing: [Mango, Grapes]

Explanation

• Creates an ArrayList to store string elements dynamically.
• remove("Banana") deletes an element by value, while remove(0) deletes by index.
• Elements automatically shift after removal.
• Prints the updated list.

3. Searching Elements

import java.util.ArrayList;

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

        ArrayList<String> list = new ArrayList<>();

        // Adding elements
        list.add("Apple");
        list.add("Banana");
        list.add("Mango");

        // Searching for an element
        if (list.contains("Mango")) {
            System.out.println("Mango is present in the list");
        }
    }
}

Mango is present in the list

Explanation

• Creates an ArrayList to store String elements.
• Adds elements using the add() method.
• contains("Mango") checks whether "Mango" exists in the list.
• Prints a message if the element is found.

4. Updating Elements

import java.util.ArrayList;

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

        ArrayList<String> list = new ArrayList<>();

        // Adding elements
        list.add("Apple");
        list.add("Banana");
        list.add("Mango");

        // Updating element at index 0
        list.set(0, "Orange");

        // Print updated list
        System.out.println("After Updating: " + list);
    }
}

After Updating: [Orange, Banana, Mango]

Explanation

• Creates an ArrayList to store String elements.
• Adds elements using add() method.
• set(0, "Orange") replaces the element at index 0.

5. Sorting a Collection

import java.util.ArrayList;
import java.util.Collections;

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

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

        // Adding elements
        fruits.add("Banana");
        fruits.add("Apple");
        fruits.add("Mango");
        fruits.add("Grapes");

        // Sorting the list in ascending order
        Collections.sort(fruits);

        // Print sorted list
        System.out.println("After Sorting: " + fruits);
    }
}

After Sorting: [Apple, Banana, Grapes, Mango]

Explanation:

• Creates an ArrayList named fruits.
• Adds multiple fruit names to the list.
• Collections.sort(fruits) sorts elements in ascending (natural) order.

Methods of Collections Class