How To Sort a List in Java with Advanced Example

In this tutorial, we will discuss the sort list in Java with the help of examples. We will also discuss how to use it in our own way to implement the Java sort list of objects. Hence, list is an interface, and we usually apply one of its applications, such as linked list or array list.

Here are the following methods for sorting of the list in Java:

• Stream.sorted() method
• Comparator.reverseOrder() method
• Comparator.naturalOrder() method
• Collections.reverseOrder() method
• Collections.sort() method

Using Java stream.sorted() method

In Java Stream.sorted() method it will give two methods for sorting the list. The stream interface will give a sorted() method for sorting a list. It will specify in Stream interface in java.util package. When the elements are not equal, it will send java.lang.ClassCastException.

The syntax method is the following below:

Stream<S> sorted()  

Parameter

S: This is a type of stream element.

Using Java Stream.sorted(Comparator comparator)

The comparator.reverseOrder() method will provide a stream sorted that is sorted using the defined comparator.

The syntax used is the following:

Stream<R> sorted(Comparator<? Strong R> comparator)  

Parameter

• R is a type of stream element.
• We can use comparator to compare elements.

For example, we will use the following method:

• Stream() is an API that handles groupings of objects in Java 8.
• We will use the collect() method to receive elements within a stream and store them in a compilation.
• The collector that compiles all of the input elements into a list in encounter order is returned by the toList() function.

import java.util.*;  
import java.util.stream.*;  
public class SortListExample1  
{  
public static void main(String[] args)   
{  
//returns a list view   
List<String> Namelist = Arrays.asList("Paul", "Glenn", "Caren", "Elijah", "Jude", "Adonis");  
List<String> sortedList = Namelist.stream().sorted().collect(Collectors.toList());     
sortedList.forEach(System.out::println);  
}  
}  

Output:

Using Java Comparator.reverseOrder() method

In Java program, a reverseOrder() method is a comparator interface which is specified in java.util package. The comparator method will return the reverse ordering. It will throws NullPointerException when matching a null.

The syntax used:

static <R extends Comparable<? R>> Comparator<R> reverseOrder()  

The term comparable will be the interface and belong to a java.lang package.

Parameters

R: It is a comparable type of element to be matched.

Let’s look at the Example of Java Comparator.reverseOrder():

import java.util.*;  
import java.util.stream.Collectors;  
public class ComparatorSortListExample2  
{  
public static void main(String[] args)  
{  
//returns a list view   
List<String> Comparatorlist = Arrays.asList("61", "ab", "db", "hi", "de", "hs", "70", "45", "91");      
List<String>ComparatorsortedList=Comparatorlist.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());  
sortedList.forEach(System.out::println);  
}  
}  

Output:

Used Comparator.naturalOrder() method

The Comparator.naturalOrder() method will return into a comparator that measures the comparable objects in a natural order. If we will comparing the null, it will throw NullPointerException.

Syntax used:

Static <R extends Comparable <? string R>> Comparator<T> naturalOrder() 

Parameters

R: This is the Comparable type of element and it should be compared.

Here is the example of Comparator.naturalOrder() method:

import java.util.*;  
public class ComparableNaturalOrderListExample  
{  
public static void main(String[] args)   
{  
List<String> name = Arrays.asList("Jhonny", "Jhenny", "Joseph", "Jackie", "", "Jeffrey");  
List<String> name1 = Arrays.asList("Jhonny", "Jhenny", "Joseph", "Jackie", "", "Jeffrey");  
System.out.println(name);  
name.sort(String.CASE_INSENSITIVE_ORDER); 
System.out.println(name);         
name.sort(Comparator.naturalOrder()); 
System.out.println(name);  

name1.sort(Comparator.naturalOrder());  
System.out.println(name1);  
}  
}  

Output:

Using Java Collections.reverseOrder() method

In Java program, a Collections.reverseOrder() method is a set of class which exist in a java.lang package. The comparator will return that requires a natural order.

Syntax Used:

public static <String> Comparator<String> reverseOrder() 

Parameters

String: Is the class of the objects which is to be compared by the comparator.

Let’s have a look at the example of Java Collections.reverseOrder() method below:

import java.util.Arrays;  
import java.util.Collections;  
import java.util.List;  
public class ReverseOrderExample4  
{  
public static void main(String args[])   
{  
List<Integer> reverseOrderlist = Arrays.asList(100,20,-200,400,50,-203,0);  
Collections.sort(reverseOrderlist, Collections.reverseOrder());  
System.out.println(reverseOrderlist);  
}  
}  

Output:

Using Java Collections.sort() method

In Java program, the Java Collections.sort() method is the collections of class which have two methods for sorting a list:

Java Sort() Method

A sort() method is a list of sort in ascending order, which is according to the essential ordering of its elements.

We will use the syntax:

public static <S extends Comparable<? Java S>> void sort() (List<S> list) 

Parameters

S: It is a type of parameter to be compared.

List: This is the list which is to be sorted.

Let’s look at the example of the collection sorted list below:

import java.util.*;  
public class ExampleSortList  
{  
public static void main(String[] args)   
{  
List<String> SortList = new ArrayList<String>();  
SortList.add("4");  
SortList.add("8");  
SortList.add("6");  
SortList.add("9");  
SortList.add("3");  
Collections.sort(SortList);    //sorts array list  
for(String str: SortList)   
System.out.print(" "+str);  
}  
}  

Output:

Conclusion

To conclude, we already learn the sort a list in java with the detailed explanation. Also we learn the methods of sort a list java like Stream.sorted() method, Comparator.reverseOrder() method, Comparator.naturalOrder() method, Collections.reverseOrder() method, and Collections.sort() method.

Common Java array and list patterns

• Fixed-size array. Declared with int[] nums = new int[10]; — size cannot change.
• ArrayList. Resizable via list.add(x) and list.remove(i). Backed by an internal array that grows as needed.
• LinkedList. Doubly-linked list — faster inserts and removes in the middle, slower random access than ArrayList.
• Arrays.asList(). Wraps an array as a fixed-size list. Cannot add or remove but can call set(i, val).
• List.of(). Java 9+ — creates an immutable list. Any mutation throws UnsupportedOperationException.

Working code example

// Modern Java array + list handling
import java.util.*;
import java.util.stream.*;

public class ArrayListExamples {
    public static void main(String[] args) {
        // Array
        int[] numbers = {1, 2, 3, 4, 5};

        // ArrayList (resizable)
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");

        // Stream API for filter + transform
        List<Integer> doubled = Arrays.stream(numbers)
                                       .filter(n -> n > 2)
                                       .map(n -> n * 2)
                                       .boxed()
                                       .collect(Collectors.toList());

        System.out.println(doubled); // [6, 8, 10]
    }
}

Common pitfalls

• ArrayIndexOutOfBoundsException. Array indices are 0-based — arr[arr.length] throws. Use arr.length - 1 for the last element.
• ConcurrentModificationException. Modifying a list during iteration (except via the iterator’s own remove) throws this. Use an explicit Iterator or collect changes and apply after.
• Arrays.asList() on primitives. Returns a List with a single element (the array itself), not a list of ints. Use Arrays.stream(primitiveArray).boxed().collect(...) instead.

Best practices

• Prefer List over T[] in method signatures — lists give you generics, size(), stream(), and Collections utilities.
• Use List.of / Set.of / Map.of for small immutable collections (Java 9+).
• Pre-size ArrayLists when you know the count — new ArrayList<>(1000) avoids repeated array copies during growth.

Adones Evangelista

Programmer & Technical Writer at PIES IT Solution

Adones Evangelista is a programmer and writer at PIES IT Solution, author of over 900 tutorials and error-fix guides at itsourcecode.com. Specializes in JavaScript, Django, Laravel, and Python error debugging covering ValueError, TypeError, AttributeError, ModuleNotFoundError, and RuntimeError, plus C/C++ and PHP capstone projects for BSIT students.

Expertise: JavaScript · Python · Django · Laravel · Error Debugging · C/C++
 · View all posts by Adones Evangelista →