Java sort arraylist of objects – Comparable and Comparator example

Many time we need to sort arraylist of objects by field or alphabetically, especially if you are working on a domain where people are your main entities (e.g. HR), you will encounter this requirement more frequently. There are many ways to sort such lists, which ranges from sorting on client UI using javascript to sort arraylist of objects on server side using complex algorithm, and sometimes in database too.

If you DO NOT have millions of records for sorting at a time (for which DB query is best way), I will recommend you to consider Comparable or Comparator interfaces.

Table of Contents

1. Employee - Model Class
2. Comparable Interface
3. Comparator Interface
4. Comparator in Java 8
5. SortedSet and SortedMap
6. hashCode() and equals()

1. Employee – Model Class

Our Employee class is plain old class with four fields: id, firstName, lastName and age. I have chosen these fields purposefully.

package corejava.compare;

public class Employee {
	private int id = -1;
	private String firstName = null;
	private String lastName = null;
	private int age = -1;

	public Employee(int id, String fName, String lName, int age) {
		this.id = id;
		this.firstName = fName;
		this.lastName = lName;
		this.age = age;
	}

	// Setters and Getters

	@Override
	public String toString() {
		return "Employee : " + id + " - " + firstName + " - " + lastName
		+ " - " + age + "n";
	}
}

2. Java sort arraylist of objects – Comparable Example

Comparable interface provides one method compareTo(T o) to implement in any class so that two instances of that class can be compared.

Method syntax is:

public int compareTo(T o);

Here, out of two instances to compare, one is instance itself on which method will be invoked, and other is passed as parameter o.

Lets see how our Employee class will look after implementing Comparable interface.

package corejava.compare;

public class Employee implements Comparable<Employee> {

	private int id = -1;
	private String firstName = null;
	private String lastName = null;
	private int age = -1;

	public Employee(int id, String fName, String lName, int age) {
		this.id = id;
		this.firstName = fName;
		this.lastName = lName;
		this.age = age;
	}

	@Override
	public int compareTo(Employee o) {
		return this.id - o.id;
	}

	// Setters and Getters

	@Override
	public String toString() {
		return "Employee : " + id + " - " + firstName + " - " + lastName + " - " + age + "\n";
	}
}

Default way to sort list of employees, in our case, is by their id. Whatever, your default sorting order is, use in compare() method.

In implemented compare() method, we have simply returned the difference in employee ids of two instances. Two equal employee ids will return zero, indicating the same object.

2.1. Collections.sort()

Lets test our compare() method implemented in above Employee class.

package corejava.compare;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestSorting {
	public static void main(String[] args) {
		Employee e1 = new Employee(1, "aTestName", "dLastName", 34);
		Employee e2 = new Employee(2, "nTestName", "pLastName", 30);
		Employee e3 = new Employee(3, "kTestName", "sLastName", 31);
		Employee e4 = new Employee(4, "dTestName", "zLastName", 25);

		List<Employee> employees = new ArrayList<Employee>();
		employees.add(e2);
		employees.add(e3);
		employees.add(e1);
		employees.add(e4);

		// UnSorted List
		System.out.println(employees);

		Collections.sort(employees);

		// Default Sorting by employee id
		System.out.println(employees);
	}
}

In the above program, first print statement prints an unsorted list of employees and in the second print statement, employees are sorted by their employee id.

//Unsorted

[Employee : 2 - nTestName - pLastName - 30
, Employee : 3 - kTestName - sLastName - 31
, Employee : 1 - aTestName - dLastName - 34
, Employee : 4 - dTestName - zLastName - 25]

//Sorted

[Employee : 1 - aTestName - dLastName - 34
, Employee : 2 - nTestName - pLastName - 30
, Employee : 3 - kTestName - sLastName - 31
, Employee : 4 - dTestName - zLastName - 25]

3. Java sort arraylist of objects – Comparator Example

So, now we can sort a list of employees by their id. Now let’s consider a case where we want to sort employees list based on some user input which is essentially sorting field i.e. sometimes he wants to sort by first name, sometimes sort by age also.

This can be achieved by jquery plugins easily, but what if browser has disables the javascript. You will have to sort the list on the server side only to not break the application functionality.

Here comes the Comparator interface to rescue you. A Comparator can be used to sort a collection of instances on some particular basis. To sort of different fields, we need multiple Comparator implementations.

3.1. Comparator interface example

We have determined multiple implementations for different sorting cases. Let’s write them.

3.1.1. First name sorter

package corejava.compare;

import java.util.Comparator;

public class FirstNameSorter implements Comparator<Employee>{

@Override
public int compare(Employee o1, Employee o2) {
return o1.getFirstName().compareTo(o2.getFirstName());
}
}

3.1.2. Last name sorter

package corejava.compare;

import java.util.Comparator;

public class LastNameSorter implements Comparator<Employee> {

	@Override
	public int compare(Employee o1, Employee o2) {
		return o1.getLastName().compareTo(o2.getLastName());
	}

}

3.1.3. Age sorter

package corejava.compare;

import java.util.Comparator;

public class AgeSorter implements Comparator<Employee> {
	@Override
	public int compare(Employee o1, Employee o2) {
		return o1.getAge() - o2.getAge();
	}
}

3.2. How to compare with Comparator

So theoretically, we should be able to sort of any field at our wish with minimum code. Let’s see if we really are:

package corejava.compare;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestSorting 
{
	public static void main(String[] args) 
	{
		Employee e1 = new Employee(1, "aTestName", "dLastName", 34);
		Employee e2 = new Employee(2, "nTestName", "pLastName", 30);
		Employee e3 = new Employee(3, "kTestName", "sLastName", 31);
		Employee e4 = new Employee(4, "dTestName", "zLastName", 25);

		List<Employee> employees = new ArrayList<Employee>();
		employees.add(e2);
		employees.add(e3);
		employees.add(e1);
		employees.add(e4);

		// UnSorted List
		System.out.println(employees);

		Collections.sort(employees);

		// Default Sorting by employee id
		System.out.println(employees);

		Collections.sort(employees, new FirstNameSorter());

		// Sorted by firstName
		System.out.println(employees);

		Collections.sort(employees, new LastNameSorter());

		// Sorted by lastName
		System.out.println(employees);

		Collections.sort(employees, new AgeSorter());

		// Sorted by age
		System.out.println(employees);
	}
}

Output:
//Unsorted

[Employee : 2 - nTestName - pLastName - 30
, Employee : 3 - kTestName - sLastName - 31
, Employee : 1 - aTestName - dLastName - 34
, Employee : 4 - dTestName - zLastName - 25]

//Default sorting based on employee id

[Employee : 1 - aTestName - dLastName - 34
, Employee : 2 - nTestName - pLastName - 30
, Employee : 3 - kTestName - sLastName - 31
, Employee : 4 - dTestName - zLastName - 25]

//Sorted by first name

[Employee : 1 - aTestName - dLastName - 34
, Employee : 4 - dTestName - zLastName - 25
, Employee : 3 - kTestName - sLastName - 31
, Employee : 2 - nTestName - pLastName - 30]

//Sorted by last name

[Employee : 1 - aTestName - dLastName - 34
, Employee : 2 - nTestName - pLastName - 30
, Employee : 3 - kTestName - sLastName - 31
, Employee : 4 - dTestName - zLastName - 25]

//Sorted by age

[Employee : 4 - dTestName - zLastName - 25
, Employee : 2 - nTestName - pLastName - 30
, Employee : 3 - kTestName - sLastName - 31
, Employee : 1 - aTestName - dLastName - 34]

Above class’s output shows clearly, now we are able to sort the list of employees on any field using appropriate Comparator implementation.

4. Comparator in Java 8

Latest Lambda changes have made using Comparator a lot easier than ever before.

List<Employee> employees  = getEmployeesFromDB();
 
//Sort all employees by first name
employees.sort(Comparator.comparing(e -> e.getFirstName()));
 
//OR you can use below
employees.sort(Comparator.comparing(Employee::getFirstName));

//Sort all employees by first name in reverse order
Comparator<Employee> comparator = Comparator.comparing(e -> e.getFirstName());
employees.sort(comparator.reversed());

//Sorting on multiple fields; Group by.
Comparator<Employee> groupByComparator = Comparator.comparing(Employee::getFirstName).thenComparing(Employee::getLastName);
employees.sort(groupByComparator);

Read More: Java 8 Comparator Example

5. Java sort arraylist of objects – SortedSet and SortedMap

Its important to understand the importance of both interfaces in code collection APIs which provide implicit behavior sort list of objects by property. Such APIs are for example SortedMap or SortedSet.

These collections store elements in sorted order. To determining the sorting, they also use compare() method. Always remember if you Employee class does not implement Comparable interface and you are not using Comparator also, then adding elements in sorted collections will give you error.

Exception in thread "main" java.lang.ClassCastException: corejava.compare.Employee cannot be cast to java.lang.Comparable
at java.util.TreeMap.put(Unknown Source)
at java.util.TreeSet.add(Unknown Source)
at corejava.compare.SortedSetTest.main(SortedSetTest.java:17)

So, it is necessary to use either of both interfaces to able to store instances in sorted collections.

5.1. SortedSet with Comparable

If you are not using Comparator implementation, then Employee class’s compare() method will be used for sorting.

package corejava.compare;

import java.util.SortedSet;
import java.util.TreeSet;

public class SortedSetTest 
{
	public static void main(String[] args) 
	{
		SortedSet<Employee> set = new TreeSet<Employee>();

		Employee e1 = new Employee(1, "aTestName", "dLastName", 34);
		Employee e2 = new Employee(2, "nTestName", "pLastName", 30);
		Employee e3 = new Employee(3, "kTestName", "sLastName", 31);
		Employee e4 = new Employee(4, "dTestName", "zLastName", 25);

		set.add(e2);
		set.add(e3);
		set.add(e1);
		set.add(e4);

		System.out.println(set);
	}
}

Program output:

[Employee : 1 - aTestName - dLastName - 34
, Employee : 2 - nTestName - pLastName - 30
, Employee : 3 - kTestName - sLastName - 31
, Employee : 4 - dTestName - zLastName - 25]

5.1. SortedSet with Comparator

If you want to add some other sorting behavior using Comparator implementation, you can pass the Comparator to constructor of sorted collection. e.g.

package corejava.compare;

import java.util.SortedSet;
import java.util.TreeSet;

public class SortedSetTest {
	public static void main(String[] args) 
	{
		SortedSet<Employee> set = new TreeSet<Employee>(new FirstNameSorter());

		Employee e1 = new Employee(1, "aTestName", "dLastName", 34);
		Employee e2 = new Employee(2, "nTestName", "pLastName", 30);
		Employee e3 = new Employee(3, "kTestName", "sLastName", 31);
		Employee e4 = new Employee(4, "dTestName", "zLastName", 25);

		set.add(e2);
		set.add(e3);
		set.add(e1);
		set.add(e4);

		System.out.println(set);
	}
}

Program output:

[Employee : 1 - aTestName - dLastName - 34
, Employee : 2 - nTestName - pLastName - 30
, Employee : 3 - kTestName - sLastName - 31
, Employee : 4 - dTestName - zLastName - 25]

In above code, Comparator will take precedence and will become default sort order. So easy it is, right??

6. hashCode() and equals()

If you have overridden equals() method in your Employee class, always remember to honor its behavior.

If two objects are equal using equals() method then compare() method should return ‘0‘.

I hope to be clear enough in describing how to sort arraylist of objects. If you still have left with some doubts, leave a comment. I will be happy to resolve.

Happy Learning !!