Java Sort Collection – Collections.sort()

Learn to use Collections.sort() method to sort collections in java with examples. By default, this method sorts the unsorted list into ascending order, according to the natural ordering of its elements.

1) Collections.sort( list )

1. It sorts the specified list into ascending order or their natural order.
2. All elements in the list must implement the Comparable interface.
3. All elements in the list must be mutually comparable and should not throw ClassCastException.
4. This sort is guaranteed to be stable. It means that equal elements will not be reordered as a result of the sort.
5. The specified list must be modifiable, but need not be resizable.
6. Method does not return any value.

1.1) Natural sort (ascending and descending)

List<String> names = Arrays.asList("Alex", "Charles", "Brian", "David");

//Natural order
Collections.sort(names);	//[Alex, Brian, Charles, David]

//Reverse order
Collections.sort(names, Collections.reverseOrder());	[David, Charles, Brian, Alex]	

1.2) Custom sort

You may need to sort list of domain objects which have their own sorting logic. In that case, implement the Comparator interface in those domain class and use same approach as above.

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

public class JavaSort 
{
	public static void main(String[] args) 
	{
		ArrayList<Employee> employees = getUnsortedEmployeeList();
		
		Collections.sort(employees);
		
		System.out.println(employees);
		//[E [id=13], E [id=46], E [id=80], E [id=90], E [id=93]]
		
		Collections.sort(employees, Collections.reverseOrder());
		
		System.out.println(employees);
		//[E [id=93], E [id=90], E [id=80], E [id=46], E [id=13]]
	}

	private static ArrayList<Employee> getUnsortedEmployeeList() 
	{
		ArrayList<Employee> list = new ArrayList<>();
		Random rand = new Random(10);
        
        for(int i = 0; i < 5; i++) {
            Employee e = new Employee();
            e.setId(rand.nextInt(100));
            list.add(e);
        }
        return list;
	}
}

And domain object Employee is as below. Checkout for comparison logic.

public class Employee implements Comparable< Employee >{
 
    private Integer id;
    
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + "]";
	}
	@Override
	public int compareTo(Employee o) {
		return this.getId().compareTo(o.getId());
	}
}

2) Collections.sort( list, Comparator )

If domain object does not implement Comparable interface, then you can use custom Comparator implementations. Use lambda expression to even more shorten the syntax.

2.1) Custom Comparator

Comparator<Employee> compareById = new Comparator<Employee>() {
	@Override
	public int compare(Employee o1, Employee o2) {
		return o1.getId().compareTo(o2.getId());
	}
};

//or use lambda expression

Comparator<Employee> compareById = (Employee o1, Employee o2) -> 
				o1.getId().compareTo( o2.getId() );

// use any other property

//First name sorter
Comparator<Employee> compareByFirstName = (Employee o1, Employee o2) ->
					o1.getFirstName().compareTo( o2.getFirstName() );
//Last name sorter
Comparator<Employee> compareByLastName = (Employee o1, Employee o2) -> 
					o1.getLastName().compareTo( o2.getLastName() );

2.2) Sort with Comparator

ArrayList<Employee> employees = getUnsortedEmployeeList();
			
Comparator<Employee> compareById = (Employee o1, Employee o2) -> o1.getId().compareTo( o2.getId() );

Collections.sort(employees, compareById);
//[E [id=13], E [id=46], E [id=80], E [id=90], E [id=93]]

Collections.sort(employees, compareById.reversed());
//[E [id=93], E [id=90], E [id=80], E [id=46], E [id=13]]

Happy Learning !!

References:

Collections.sort()
List.sort()