Java Collections Class

The Java Collections class is part of the java.util package and offers static utility functions that work with different types of collections like List, Set, and Map. These functions are commonly utilized for tasks such as sorting, searching, reversing, and synchronization.

If null collections or class objects are passed to the methods of this class, they will all raise a NullPointerException.

To read more Collections in Java

Java Collections Class Methods

Let's use some of the above methods in Java program.

Java Collections Class Method Examples

Collections.addAll Method

The function appends all the specified items to the designated collection. Items can be provided either one by one or in an array format.

Syntax:

public static <T> boolean addAll(Collection<? super T> c, T... elements)

Example

import java.util.*;  

public class Main {  

    public static void main(String a[]){      

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

        list.add("C");  

        list.add("Core Java");  

        list.add("Advance Java");  

        System.out.println("Initial collection value:"+list);  

        Collections.addAll(list, "Servlet","JSP");  

        System.out.println("After adding elements collection value:"+list);  

        String[] strArr = {"C#", ".Net"};  

        Collections.addAll(list, strArr);  

        System.out.println("After adding array collection value:"+list);  

    }  

}

Output:

Initial collection value:[C, Core Java, Advance Java]

After adding elements collection value:[C, Core Java, Advance Java, Servlet, JSP]

After adding array collection value:[C, Core Java, Advance Java, Servlet, JSP, C#, .Net]

Collections.max Method

This function retrieves the highest value from the provided set of data.

Syntax:

public static <T extends Comparable<? super T>> T max(Collection<? extends T> coll)

Example

import java.util.*;  

public class Main {  

    public static void main(String a[]){         

        List<Integer> list = new ArrayList<Integer>();  

        list.add(46);  

        list.add(67);  

        list.add(24);  

        list.add(16);  

        list.add(8);  

        list.add(12);  

        System.out.println("Value of maximum element from the collection: "+Collections.max(list));  

    }  

}

Output:

Value of maximum element from the collection: 67

Explanation

Within the provided code snippet, there exists an array of numerical values [46, 67, 24, 16, 8, 12]. The function collection.max has been employed to determine the highest number within the array, which in this case is 67. This function operates by adhering to the inherent sequence of integers. Subsequently, the function proceeds to display the minimum value, showcasing a straightforward approach to identifying the largest element within any given collection.

Collections.min Method

The function provided retrieves the smallest item from the specified set of data.

Syntax:

public static <T extends Comparable<? super T>> T min(Collection<? extends T> coll)

Example

import java.util.*;  

public class Main {  

    public static void main(String a[]){         

        List<Integer> list = new ArrayList<Integer>();  

        list.add(46);  

        list.add(67);  

        list.add(24);  

        list.add(16);  

        list.add(8);  

        list.add(12);  

        System.out.println("Value of minimum element from the collection: "+Collections.min(list));  

    }  

}

Output:

Value of minimum element from the collection: 8

Explanation

Within the provided code snippet, an array of numbers [46, 67, 24, 16, 8, 12] is utilized. By employing the collection.min function, the code identifies the minimum value within the array, in this case being 8. The functionality of this method hinges on the inherent numerical order. Subsequently, the identified minimum value is outputted. This approach serves as a straightforward means to pinpoint the smallest element within a given collection.

Collections.sort Method

The technique is employed to arrange the provided items. In cases where the items do not support Comparable, this technique will result in a ClassCastException.

<strong>Syntax:</strong></p>

<p>public static <T extends Comparable<? Super T>> void sort(List<T>list)

Example

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

public class Main {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(14, 5, 11, 7);

        Collections.sort(numbers);

        System.out.println(numbers);  

    }

}

Output:

[5, 7, 11, 14]

Explanation

Within the provided code snippet, a list of integers (14, 5, 11, 7) is generated using Arrays.asList. The list is then sorted in ascending order utilizing the Collections.sort method, following their natural order (i.e., from the smallest to the largest values). Subsequently, the sorted list [5, 7, 11, 14] is printed out using the System.out.println method.

Collections.reverse Method

This approach directly alters the original list, offering a straightforward method to reverse a collection without requiring any custom code.

Syntax:

public static void reverse(List<?> list)

Example

import java.util.*;

public class Main {

    public static void main(String[] args) {

        List<String> fruits = new ArrayList<>(Arrays.asList("Banana", "Pineapple", "Kiwi"));

        Collections.reverse(fruits);

        System.out.println(fruits);  

    }

}

Output:

[Kiwi, Pineapple, Banana]

Explanation

The code snippet above demonstrates the creation of a list of fruits ("Banana", "Pineapple", "Kiwi") by utilizing Arrays.asList and encapsulating it within an ArrayList. Subsequently, the list's element order is reversed by invoking the Collections.reverse method.

The method directly alters the initial list, resulting in a change in order from [Banana, Pineapple, Kiwi] to [Kiwi, Pineapple, Banana]. Consequently, the console displays the reversed list. This approach is straightforward and effective for reversing collections.

Collections.shuffle Method

The provided list is randomly shuffled using the default randomization method by this function.

Syntax:

public static void shuffle(List<?> list)

Example

import java.util.*;

public class Main {

    public static void main(String[] aargs){

        List<Integer> numbers = new ArrayList<>(Arrays.asList(5, 6, 7, 8, 9));

        Collections.shuffle(numbers);

        System.out.println(numbers);

    }

}

Output:

[8, 7, 5, 9, 6]

Explanation

Within the provided code snippet, a sequence of integers (5, 6, 7, 8, 9) has been generated by utilizing ArrayList and encapsulating it within an ArrayList instance. Subsequently, the collection.shuffle function is employed to shuffle the elements within the list, thereby introducing a randomization factor to their arrangement.

Once the list is shuffled, it could be displayed as [8, 7, 5, 9, 6]. The sequence will vary with each execution of the code. This approach is beneficial in situations such as card games or any scenario that requires the random reordering of a group of elements.

Collections.swap Method

This function exchanges the elements located at the given positions within the specified list. When the positions provided are the same, calling this function will not alter the list.

Syntax:

public static void swap(List<?> list, int i, int j)

Parameters:

list: The list in which to swap elements.

i: the index of one element to be swapped.

j: the index of the other element to be swapped.

Example

import java.util.*;

public class Main {

    public static void main(String[] args) {

        List<String> names = new ArrayList<>(Arrays.asList("Daisy", "Ginny",        "Georgia"));

        Collections.swap(names, 0, 2);

        System.out.println(names);  

    }

}

Output:

[Georgia, Ginny, Daisy]

Explanation

In the code snippet provided, a list of names has been initialized as "Daisy", "Ginny", and "Georgia". To exchange the elements at index 0 and 2, the Collections.swap function is employed, resulting in the interchange of "Daisy" with "Georgia".

The list transforms to [Georgia, Ginny, Daisy] after the swap operation. This technique is beneficial for efficiently rearranging particular elements within a list without the need for additional code.

Collections.copy Method

The copy function duplicates items from a source list to a target list. It is important to ensure that the target list has sufficient capacity to accommodate all the elements being copied from the source list.

Syntax:

public static <T> void copy(List<? super T> dest, List<? extends T> src)

Example

import java.util.*;

public class Main {

       public static void main(String[] args) {

                  List<String> source = new ArrayList<>(Arrays.asList("A", "B", "C"));

                   List<String> dest = new ArrayList<>(Arrays.asList("X", "Y", "Z"));

                    Collections.copy(dest, source);

                    System.out.println(dest);         

       }

}

Output:

[A, B, C]

Explanation

In the provided code snippet, there are two lists present: the first list is referred to as the source list containing elements "A", "B", and "C", while the second list is known as the destination list containing elements "X", "Y", and "Z". By utilizing the collections.copy method, all elements from the source list are duplicated into the destination list, thereby overwriting any previous values at corresponding positions. Following the copying process, the destination list will be updated to include the elements [A, B, C].

Collections.emptyList Method

The method emptyList generates a list devoid of any elements, rendering it immutable. Consequently, it prohibits any operations like addition, removal, or modification within the list.

Syntax:

public static <T> List<T> emptyList()

Example

import java.util.*;

public class Main {

           public static void main(String[] args) {

            List<String> emptyList = Collections.emptyList();

                  System.out.println(emptyList); 

                }

           }

Output:

Explanation

In the following illustration, we have utilized Collection.emptyList to create a list that is devoid of any elements. This list is immutable, meaning that it cannot be modified by adding or removing elements. This approach is beneficial when there is a necessity to return an empty list from a function while ensuring its integrity by preventing any alterations.

Collections.singletonList Method

The function provides an unchangeable list that includes solely the designated object. This resulting list can be serialized. It furnishes a fixed list comprising solely the designated object.

Syntax:

public static <T> List<T> singletonList(T o)

Where,

T: the class of the objects in the list

o: the only item that will be saved in the list that is returned.

Example

import java.util.*;

public class Main {

     public static void main(String[] args) {

     List<String> singleton = Collections.singletonList("Hello");

           System.out.println(singleton);  

           } 

}

Output:

[Hello]

Explanation

In Java, the method mentioned above is utilized to generate an immutable list with a single element. This indicates that the list cannot be altered by adding, removing, or replacing any items. Such lists are beneficial when a constant, singular value list is required for immediate utilization. The provided illustration demonstrates a list comprising solely the term "Hello", which when displayed, appears as [Hello]. This particular approach is commonly employed when there is a necessity to deliver a one-item list without concerns of potential modifications by others at a later time.

Conclusion

Java's Collections class offers a variety of convenient utilities for managing collections such as lists, sets, and maps. It provides pre-defined functions for performing typical operations like sorting, reversing, shuffling, and copying. By leveraging these functionalities, developers can reduce the amount of code they write, resulting in more straightforward and comprehensible programs. Utilizing the Collections class when working with collections can significantly streamline development processes.