How to Sort ArrayList in Java

In Java, Collection is a framework that provides interfaces (Set, List, Queue, etc.) and classes (ArrayList, LinkedList, etc.) to store the group of objects. These classes store data in an unordered manner. Sometimes we need to arrange data in an ordered manner which is known as sorting. The sorting can be performed in two ways either in ascending or descending order.

In this section, we will learn how to sort ArrayList in ascending and descending order.

ArrayList

In Java, ArrayList is a class of Collections framework that is defined in the java.util package. It inherits the AbstractList class. It dynamically stores the elements. The advantage of ArrayList is that it has no size limit. It is more flexible than the traditional array. It may have duplicate elements. We can also use all the methods of List interface because it implements the List interface.

We can sort an ArrayList in two ways ascending and descending order. The Collections class provides two methods to sort an ArrayList in Java.

sort()
reverseOrder()

Collections.sort() Method

An ArrayList can be sorted by using the sort() method of the Collections class in Java. It accepts an object of ArrayList as a parameter to be sort and returns an ArrayList sorted in the ascending order according to the natural ordering of its elements.

Syntax

Remember: All elements in the ArrayList must be mutually comparable, else it throws ClassCastException. Here, mutually comparable means the list must have the same type of elements. For example, consider the snippet of the code:

//creating an instance of ArrayList that contains String type elements
ArrayList<String> list = new ArrayList<String>(); 
list.add("Computer");
list.add(123); 
list.add("Hard Disk");
list.add("DRAM");

In the above example, we see that a list has four elements out of which three elements are of String type and one is Integer type. The three elements that are in String are mutually comparable but the element that is of Integer type is not comparable with the other three. Hence, the list must have the same type of elements.

Collections.reverseOrder() Method

If we want to sort ArrayList in descending order, Java Collections class provides reverseOrder() method. It allows us to sort the ArrayList in reverse-lexicographic order.

Syntax

It returns a comparator that imposes the reverse of the natural ordering on a collection of objects that implement the Comparable interface.

Remember that we do not directly invoke the reverseOrder() method. We use it along with the Collection.sort() method, as follows.

Therefore, the sorting of ArrayList in descending order done in two steps, first the ArrayList sorts the data in ascending order, after that the sorted data is reversed by the reverseOrder() method.

Let's create programs that sort ArrayList in ascending order.

Sort ArrayList in Ascending Order

In the following example, we have created an ArrayList of type String and added some elements into it. After that we have invoked sort() method of the Collections class and passed the object of the ArrayList class i.e., list that sorts the elements in the ascending order.

// File Name: SortArrayListExample1.java

import java.util.*; 
public class SortArrayListExample1
{ 
public static void main(String args[]) 
{ 
// creating object of ArrayList class
ArrayList<String> list = new ArrayList<String>(); 
// adding elements to the ArrayList 
list.add("Volkswagen"); 
list.add("Toyota"); 
list.add("Porsche"); 
list.add("Ferrari"); 
list.add("Mercedes-Benz"); 
list.add("Audi"); 
list.add("Rolls-Royce");
list.add("BMW");
// printing the unsorted ArrayList 
System.out.println("Before Sorting: "+ list); 
// Sorting ArrayList in ascending Order 
Collections.sort(list); 
// printing the sorted ArrayList 
System.out.println("After Sorting: "+ list); 
} 
}

Output:

Before Sorting: [Volkswagen, Toyota, Porsche, Ferrari, Mercedes-Benz, Audi, Rolls-Royce, BMW]
After Sorting: [Audi, BMW, Ferrari, Mercedes-Benz, Porsche, Rolls-Royce, Toyota, Volkswagen]

Let's see another example that sorts an ArrayList of Integer type.

SortArrayListExample2.java

import java.util.*;
public class SortArrayListExample2
{
public static void main(String args[])
{
//creating an object of ArrayList class
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(55);
list.add(34);
list.add(98);
list.add(67);
list.add(39);
list.add(76);
list.add(81);
//printing ArrayList before sorting
System.out.println("ArrayList Before Sorting:");
for(int marks: list)
{
System.out.println(marks);
}
//sorting ArrayList in ascending order
Collections.sort(list);
//printing ArrayList after sorting
System.out.println("ArrayList After Sorting:");
for(int marks: list)
{
System.out.println(marks);
}
}
}

Output:

ArrayList Before Sorting:
55
34
98
67
39
76
81
ArrayList After Sorting:
34
39
55
67
76
81
98

Sort ArrayList in Descending Order

In the following example, we have created an ArrayList of type String and added some elements into it. After that we have invoked reverseOrder() method along with the sort() method of the Collections class and passed the object of the ArrayList class i.e., list that sorts the elements in the descending order.

SortArrayListExample3.java

import java.util.*; 
public class SortArrayListExample3
{ 
public static void main(String args[]) 
{ 
// creating object of ArrayList class
ArrayList<String> list = new ArrayList<String>(); 
// adding elements to the ArrayList 
list.add("Data Science"); 
list.add("Testing"); 
list.add("C#"); 
list.add("Basic Language"); 
list.add("UML"); 
list.add("Algorithms "); 
list.add("Computer Networks");
list.add("Python");
// printing the unsorted ArrayList 
System.out.println("Before Sorting: "+ list); 
// Sorting ArrayList in ascending Order 
// using Collection.sort() method 
Collections.sort(list, Collections.reverseOrder()); 
// Print the sorted ArrayList 
System.out.println("After Sorting: "+ list); 
} 
}

Output:

Before Sorting: [Data Science, Testing, C#, Basic Language, UML, Algorithms, Computer Networks, Python]
After Sorting: [UML, Testing, Python, Data Science, Computer Networks, C#, Basic Language, Algorithms]

SortArrayListExample4.java

import java.util.*;
public class SortArrayListExample4 
{
public static void main(String args[])
{
//creating an object of ArrayList class
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(566);
list.add(230);
list.add(123);
list.add(110);
list.add(689);
list.add(12);
list.add(95);
//printing ArrayList before sorting
System.out.println("ArrayList Before Sorting:");
for(int marks: list)
{
System.out.println(marks);
}
//sorting ArrayList in descending order
 Collections.sort(list, Collections.reverseOrder());
//printing ArrayList after sorting
System.out.println("ArrayList After Sorting:");
for(int marks: list)
{
System.out.println(marks);
}
}
}

Output:

ArrayList Before Sorting:
566
230
123
110
689
12
95
ArrayList After Sorting:
689
566
230
123
110
95
12

Implementing Comparable Interface

If you have a custom class and want to sort objects of that class in an ArrayList, you can make the class implement the Comparable interface. This interface requires implementing the compareTo() method, which defines the natural ordering of objects.

Here's an example of sorting a list of custom objects using the Comparable interface:

File Name: ImplementingCompartable.java

import java.util.ArrayList;
import java.util.Collections;
class Student implements Comparable<Student> {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // Implementing compareTo method
    @Override
    public int compareTo(Student other) {
        return this.name.compareTo(other.name);
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class ImplementingCompartable {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 20));
        students.add(new Student("Bob", 22));
        students.add(new Student("Charlie", 21));
        // Sorting the ArrayList
        Collections.sort(students);
        // Printing the sorted ArrayList
        System.out.println("Sorted ArrayList: " + students);
    }
}

Output:

Sorted ArrayList: [Student{name='Alice', age=20}, Student{name='Bob', age=22}, Student{name='Charlie', age=21}]

Using Comparator Interface

If you want to sort objects based on criteria other than their natural ordering, you can use the Comparator interface. This interface requires implementing the compare() method, which compares two objects based on a specified criterion.

Here's an example of sorting a list of custom objects using a Comparator:

File Name: UsingComparator.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class UsingComparator{
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 20));
        students.add(new Student("Bob", 22));
        students.add(new Student("Charlie", 21));
        // Sorting the ArrayList using Comparator
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                return s1.getName().compareTo(s2.getName());
            }
        });
        // Printing the sorted ArrayList
        System.out.println("Sorted ArrayList: " + students);
    }
}

Output:

Sorted ArrayList: [Student{name='Alice', age=20}, Student{name='Bob', age=22}, Student{name='Charlie', age=21}]

Conclusion

Sorting an ArrayList in Java is a fundamental operation that can be achieved using various techniques. Whether we are dealing with built-in types or custom objects, Java offers flexible methods to sort collections efficiently. By understanding these techniques, we can effectively manage and manipulate data in your Java programs.

Java sort ArrayList MCQ

1. Which method is used to sort an ArrayList in Java?

Arrays.sort()
Collections.sort()
Sort.arraylist()
Arraylist.sort()

Answer: b

Explanation: The Collections.sort() method is used to sort an ArrayList in Java. It sorts the elements in their natural order if they implement the Comparable interface.

2. How can you sort an ArrayList of custom objects by a specific field?

By implementing Comparable in the custom class
By using a custom Comparator
Both a and b
By using Collections.sort() without any parameters

Answer: c

Explanation: We can sort an ArrayList of custom objects by a specific field either by implementing the Comparable interface in the custom class or by using a custom Comparator.

3. What is the output of the following code?

 
 ArrayList<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5, 9));
Collections.sort(list);
System.out.println(list);  

[3, 1, 4, 1, 5, 9]
[1, 1, 3, 4, 5, 9]
[9, 5, 4, 3, 1, 1]
[1, 3, 4, 1, 5, 9]

Answer: b

Explanation: The code sorts the ArrayList in ascending order, resulting in [1, 1, 3, 4, 5, 9].

4. How can you sort an ArrayList of strings ignoring case differences?

Using Collections.sort() with a custom Comparator
Using Collections.sort() directly
Using Arrays.sort()
Using ArrayList.sort()

Answer: a

Explanation: To sort an ArrayList of strings while ignoring case differences, you can use Collections.sort() with a custom Comparator that implements case-insensitive comparison.

5. Which Comparator method is used for sorting in reverse order?