Collections Class in Java

Collections class is a member of the Java Collections Framework. The java.util package is the package that contains the Collections class. Collection class is basically used with the static methods that operate on the collections or return the collection. All the methods of this class throw the NullPointerException if the collection or object passed to the methods is null.  

Declaration

public class Collections extends Object

One should remember that Object is the parent class of all the classes.

Collections class fields

The collection class basically contains 3 fields i.e; EMPTY_LIST, EMPTY_SET, EMPTY_MAP, which can be used to get an immutable empty List, Map, and Set respectively.



Basic Operations

1. Adding Elements

The addAll() method of java.util.Collections class is used to add all the specified elements to the specified collection. Elements to be added may be specified individually or as an array.

Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate adding elements
// using addAll() method
  
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
  
class AddingElements {
    public static void main(String[] args)
    {
        // create a list
        List<String> items = new ArrayList<>();
  
        // add items to the list
        items.add("Shoes");
        items.add("Toys");
  
        // Add one or more elements
        Collections.addAll(items, "Fruits", "Bat", "Ball");
  
        // print the list contents
        for (int i = 0; i < items.size(); i++) {
            System.out.print(items.get(i) + " ");
        }
    }
}

chevron_right


Output

Shoes Toys Fruits Bat Ball 

2. Sorting a Collection

java.util.Collections.sort() is used to sort the elements present in the specified list of Collection in ascending order. java.util.Collections.reverseOrder() is used to sort in the descending order.

Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate sorting a
// Collections using sort() method
  
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
  
class SortingCollectionExample {
    public static void main(String[] args)
    {
          // create a list
        List<String> items = new ArrayList<>();
            
          // add elements to the list
        items.add("Shoes");
        items.add("Toys");
            
          // add one or more elements
        Collections.addAll(items, "Fruits", "Bat", "Mouse");
  
        // sorting according to default ordering
        Collections.sort(items);
            
          // print the elements
        for (int i = 0; i < items.size(); i++) {
            System.out.print(items.get(i) + " ");
        }
        System.out.println();
  
        // sorting according to reverse ordering
        Collections.sort(items, Collections.reverseOrder());
  
          // print the reverse order
        for (int i = 0; i < items.size(); i++) {
            System.out.print(items.get(i) + " ");
        }
    }
}

chevron_right


Output

Bat Fruits Mouse Shoes Toys 
Toys Shoes Mouse Fruits Bat 

3. Searching in a Collection

java.util.Collections.binarySearch() method returns the position of an object in a sorted list. To use this method, the list should be sorted in ascending order, otherwise, the result returned from the method will be wrong. If the element exists in the list, the method will return the position of the element in the sorted list, otherwise, the result returned by the method would be the – (insertion point where the element should have been present if exist)-1).



Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program demonstrating
// binarySearch using Collections.binarySearch()
  
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
  
public class BinarySearchOnACollection {
    public static void main(String[] args)
    {
          // create a list
        List<String> items = new ArrayList<>();
            
          // Add elements
        items.add("Shoes");
        items.add("Toys");
        items.add("Horse");
        items.add("Ball");
        items.add("Grapes");
  
          // sort the list
        Collections.sort(items);
            
          // binarySearch on the list
        System.out.println(
            "The index of Horse is "
            + Collections.binarySearch(items, "Horse"));
            
          // binarySearch on the list
        System.out.println(
            "The index of Dog is "
            + Collections.binarySearch(items, "Dog"));
    }
}

chevron_right


Output:

The index of Horse is 2
The index of Dog is -2

4. Copying Elements

The copy() method of java.util.Collections class is used to copy all the elements from one list into another. After the operation, the index of each copied element in the destination list will be identical to its index in the source list. The destination list must be at least as long as the source list. If it is longer, the remaining elements in the destination list are unaffected.

Java

filter_none

edit
close

play_arrow

link
brightness_4
code

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
  
class CopyOneCollectionToAnother {
    public static void main(String[] args)
    {
        // create destination list
        List<String> destination_List = new ArrayList<>();
  
        // add elements
        destination_List.add("Shoes");
        destination_List.add("Toys");
        destination_List.add("Horse");
        destination_List.add("Tiger");
  
        // print the elements
        System.out.println(
            "The Original Destination list is ");
        for (int i = 0; i < destination_List.size(); i++) {
            System.out.print(destination_List.get(i) + " ");
        }
        System.out.println();
  
        // create source list
        List<String> source_List = new ArrayList<>();
        source_List.add("Bat");
        source_List.add("Frog");
        source_List.add("Lion");
  
        // copy the elements from source to destination
        Collections.copy(destination_List, source_List);
  
        // printing the modified list
        System.out.println(
            "The Destination List After copying is ");
        for (int i = 0; i < destination_List.size(); i++) {
            System.out.print(destination_List.get(i) + " ");
        }
    }
}

chevron_right


Output

The Original Destination list is 
Shoes Toys Horse Tiger 
The Destination List After copying is 
Bat Frog Lion Tiger 

5. Disjoint Collection

java.util.Collections.disjoint() is used to check whether two specified collections are disjoint or not. More formally, two collections are disjoint if they have no elements in common. It returns true if the two collections do not have any element in common.

Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program to demostrate the working of the disjoint
// function
  
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
  
class DisjointCollectionsExample {
    public static void main(String[] args)
    {
        // create list1
        List<String> list1 = new ArrayList<>();
  
        // add elements to list1
        list1.add("Shoes");
        list1.add("Toys");
        list1.add("Horse");
        list1.add("Tiger");
  
        // create list2
        List<String> list2 = new ArrayList<>();
  
        // add elements to list2
        list2.add("Bat");
        list2.add("Frog");
        list2.add("Lion");
  
        // check if disjoint or not
        System.out.println(
            Collections.disjoint(list1, list2));
    }
}

chevron_right


Output

true

Methods of Collections

Methods

Description

addAll(Collection<? extends E> c) It is used to insert the specified collection elements in the invoking collection.
asLifoQueue​(Deque<T> deque) Returns a view of a Deque as a Last-in-first-out (Lifo) Queue.
binarySearch(List<? extends Comparable> list, T key)  This method searches the key using binary search in the specified list. 
binarySearch​(List<? extends T> list, T key, Comparator<? super T> c) Searches the specified list for the specified object using the binary search algorithm.
checkedCollection​(Collection<E> c, Class<E> type) Returns a dynamically typesafe view of the specified collection.
checkedList​(List<E> list, Class<E> type) Returns a dynamically typesafe view of the specified list.
checkedMap​(Map<K,​V> m, Class<K> keyType, Class<V> valueType) Returns a dynamically typesafe view of the specified map.
checkedNavigableMap​(NavigableMap<K,​V> m, Class<K> keyType, Class<V> valueType) Returns a dynamically typesafe view of the specified navigable map.
checkedNavigableSet​(NavigableSet<E> s, Class<E> type) Returns a dynamically typesafe view of the specified navigable set.
checkedQueue​(Queue<E> queue, Class<E> type) Returns a dynamically typesafe view of the specified queue.
 checkedSet​(Set<E> s, Class<E> type) Returns a dynamically typesafe view of the specified set.
checkedSortedMap​(SortedMap<K,​V> m, Class<K> keyType, Class<V> valueType) Returns a dynamically typesafe view of the specified sorted map.
checkedSortedSet​(SortedSet<E> s, Class<E> type) Returns a dynamically typesafe view of the specified sorted set.
copy​(List<? super T> dest, List<? extends T> src) Copies all of the elements from one list into another.
disjoint​(Collection<?> c1, Collection<?> c2) Returns true if the two specified collections have no elements in common.
emptyEnumeration() Returns an enumeration that has no elements.
emptyIterator() Returns an iterator that has no elements.
 emptyList() Returns an empty list (immutable).
emptyListIterator() Returns a list iterator that has no elements.
emptyMap() Returns an empty map (immutable).
emptyNavigableMap() Returns an empty navigable map (immutable).
emptyNavigableSet() Returns an empty navigable set (immutable).
emptySet() Returns an empty set (immutable).
emptySortedMap() Returns an empty sorted map (immutable).
emptySortedSet() Returns an empty sorted set (immutable).
enumeration​(Collection<T> c) Returns an enumeration over the specified collection.
fill​(List<? super T> list, T obj) Replaces all of the elements of the specified list with the specified element.
frequency​(Collection<?> c, Object o) Returns the number of elements in the specified collection equal to the specified object
indexOfSubList​(List<?> source, List<?> target) Returns the starting position of the first occurrence of the specified target list within the specified source list, or -1 if there is no such occurrence.
lastIndexOfSubList​(List<?> source, List<?> target) Returns the starting position of the last occurrence of the specified target list within the specified source list, or -1 if there is no such occurrence.
list​(Enumeration<T> e) Returns an array list containing the elements returned by the specified enumeration in the order they are returned by the enumeration.
max​(Collection<? extends T> coll) Returns the maximum element of the given collection, according to the natural ordering of its elements.
max​(Collection<? extends T> coll, Comparator<? super T> comp) Returns the maximum element of the given collection, according to the order induced by the specified comparator.
min​(Collection<? extends T> coll) Returns the minimum element of the given collection, according to the natural ordering of its elements.
min​(Collection<? extends T> coll, Comparator<? super T> comp) Returns the minimum element of the given collection, according to the order induced by the specified comparator.
nCopies​(int n, T o) Returns an immutable list consisting of n copies of the specified object.
newSetFromMap​(Map<E,​Boolean> map) Returns a set backed by the specified map.
replaceAll​(List<T> list, T oldVal, T newVal) Replaces all occurrences of one specified value in a list with another.
reverse​(List<?> list) Reverses the order of the elements in the specified list
reverseOrder() Returns a comparator that imposes the reverse of the natural ordering on a collection of objects that implement the Comparable interface.
 reverseOrder​(Comparator<T> cmp) Returns a comparator that imposes the reverse ordering of the specified comparator.
rotate​(List<?> list, int distance) Rotates the elements in the specified list by the specified distance.
shuffle​(List<?> list) Randomly permutes the specified list using a default source of randomness.
shuffle​(List<?> list, Random rnd) Randomly permute the specified list using the specified source of randomness.
singletonMap​(K key, V value) Returns an immutable map, mapping only the specified key to the specified value.
singleton​(T o) Returns an immutable set containing only the specified object.
singletonList​(T o) Returns an immutable list containing only the specified object.
sort​(List<T> list) Sorts the specified list into ascending order, according to the natural ordering of its elements.
sort​(List<T> list, Comparator<? super T> c) Sorts the specified list according to the order induced by the specified comparator.
swap​(List<?> list, int i, int j) Swaps the elements at the specified positions in the specified list.
synchronizedCollection​(Collection<T> c) Returns a synchronized (thread-safe) collection backed by the specified collection.
synchronizedList​(List<T> list) Returns a synchronized (thread-safe) list backed by the specified list.
synchronizedMap​(Map<K,​V> m) Returns a synchronized (thread-safe) map backed by the specified map.
synchronizedNavigableMap​(NavigableMap<K,​V> m) Returns a synchronized (thread-safe) navigable map backed by the specified navigable map.
synchronizedNavigableSet​(NavigableSet<T> s) Returns a synchronized (thread-safe) navigable set backed by the specified navigable set.
 synchronizedSet​(Set<T> s) Returns a synchronized (thread-safe) set backed by the specified set.
synchronizedSortedMap​(SortedMap<K,​V> m) Returns a synchronized (thread-safe) sorted map backed by the specified sorted map.
synchronizedSortedSet​(SortedSet<T> s) Returns a synchronized (thread-safe) sorted set backed by the specified sorted set.
unmodifiableCollection​(Collection<? extends T> c) Returns an unmodifiable view of the specified collection.
unmodifiableList​(List<? extends T> list) Returns an unmodifiable view of the specified list.
unmodifiableNavigableMap​(NavigableMap<K,​? extends V> m) Returns an unmodifiable view of the specified navigable map.
unmodifiableNavigableSet​(NavigableSet<T> s) Returns an unmodifiable view of the specified navigable set.
unmodifiableSet​(Set<? extends T> s) Returns an unmodifiable view of the specified set.
unmodifiableSortedMap​(SortedMap<K,​? extends V> m) Returns an unmodifiable view of the specified sorted map.
unmodifiableSortedSet​(SortedSet<T> s) Returns an unmodifiable view of the specified sorted set.

Attention reader! Don’t stop learning now. Get hold of all the important Java and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.