Sort Java Arraylist by Object Property: Quick Guide

Introduction

When working with Java ArrayLists, it is often necessary to sort the elements based on a specific property of the objects contained in the list. This can be achieved by implementing the Comparable interface or by using a Comparator. In this quick guide, we will explore both options and their implementation.

Using the Comparable Interface

The Comparable interface is used to define the natural ordering of objects. By implementing the Comparable interface, we can specify the order in which objects should be sorted. To use the Comparable interface, the object class must implement it and override the compareTo() method. The compareTo() method should return a negative integer, zero, or a positive integer if the current object is less than, equal to, or greater than the specified object, respectively.

Let's say we have a class named Person with two properties: name and age. To sort a list of Person objects by name, we would implement the Comparable interface as follows:

public class Person implements Comparable<Person> {
    private String name;
    private int age;

    // getters and setters

    @Override
    public int compareTo(Person p) {
        return this.name.compareTo(p.getName());
    }
}

Here, we are using the compareTo() method to compare the names of the Person objects. The compareTo() method uses the String class's compareTo() method to compare the names.

To sort an ArrayList of Person objects, we can simply call the Collections.sort() method and pass the ArrayList as a parameter:

ArrayList<Person> persons = new ArrayList<>();
// add Person objects to the ArrayList
Collections.sort(persons);

The Collections.sort() method will sort the ArrayList in ascending order based on the compareTo() method's implementation.

Using a Comparator

A Comparator is an interface that is used to define a custom ordering of objects. Unlike the Comparable interface, a Comparator can be implemented separately from the object class. To use a Comparator, we need to create a class that implements the Comparator interface and override the compare() method. The compare() method should return a negative integer, zero, or a positive integer if the first argument is less than, equal to, or greater than the second argument, respectively.

Let's say we have a class named Book with two properties: title and author. To sort a list of Book objects by the author's name, we would create a separate class that implements the Comparator interface as follows:

public class BookComparator implements Comparator<Book> {
    @Override
    public int compare(Book b1, Book b2) {
        return b1.getAuthor().compareTo(b2.getAuthor());
    }
}

Here, we are using the compare() method to compare the authors' names of the Book objects.

To sort an ArrayList of Book objects using the BookComparator class, we can call the Collections.sort() method and pass the ArrayList and the BookComparator object as parameters:

ArrayList<Book> books = new ArrayList<>();
// add Book objects to the ArrayList
Collections.sort(books, new BookComparator());

The Collections.sort() method will sort the ArrayList in ascending order based on the BookComparator class's implementation.

Conclusion

In this quick guide, we have explored two options for sorting Java ArrayLists based on object properties: using the Comparable interface and using a Comparator. Both options are easy to implement and provide a flexible way to sort ArrayLists in the desired order.