How To Sort Java List

Sorting a list in Java is a common task that we often encounter in our programming journey. Whether it’s a list of numbers, strings, or objects, having the ability to sort them in a specific order can be quite handy. In this article, I will guide you through the process of sorting a Java list, and provide some personal commentary along the way.

Choosing the Right Collection

Before we dive into the sorting algorithms, it’s important to choose the right collection to store our data. In Java, we have several options such as ArrayList, LinkedList, and TreeSet, among others. Each collection has its own strengths and weaknesses when it comes to sorting. For example, ArrayList provides fast random access but slower insertion and deletion, while LinkedList excels in rapid insertions and deletions but slower random access.

Considering the trade-offs, I personally prefer using ArrayList for sorting purposes, as it strikes a good balance between random access and insertions/deletions.

Implementing the Comparable Interface

To sort a list of custom objects, we need to implement the Comparable interface. This interface allows us to define a natural ordering for our objects based on a particular property.

Let’s say we have a Person class with properties like name, age, and height. To sort a list of Person objects based on their age, we can implement the Comparable interface as follows:


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

@Override
public int compareTo(Person otherPerson) {
return Integer.compare(this.age, otherPerson.getAge());
}
}


By implementing the Comparable interface, we provide a way for the sorting algorithm to compare two Person objects based on their age. Now, we can easily sort a list of Person objects using the Collections.sort() method.

Sorting the List

Sorting a list in Java can be done using the Collections.sort() method. This method takes a list as an argument and sorts it in ascending order based on the natural ordering of its elements.

Let’s say we have an ArrayList of Person objects named people. To sort this list based on the age of the persons, we can simply call the Collections.sort() method like this:


Collections.sort(people);


After this line of code, the people list will be sorted in ascending order based on the age property of the Person objects.

Sorting with Custom Comparators

What if we want to sort a list based on a different property or in a different order? In such cases, we can use a custom Comparator to define our own sorting logic.

Let’s say we want to sort our list of Person objects based on their height in descending order. We can create a custom Comparator like this:


public class HeightComparator implements Comparator<Person> {
@Override
public int compare(Person person1, Person person2) {
return Double.compare(person2.getHeight(), person1.getHeight());
}
}


To sort the people list using this custom comparator, we can call the Collections.sort() method with both the list and the comparator as arguments:


Collections.sort(people, new HeightComparator());


After executing this code, the people list will be sorted in descending order based on the height property of the Person objects.

Conclusion

Sorting a list in Java is a fundamental task that every developer should be familiar with. By choosing the right collection, implementing the Comparable interface, and utilizing custom comparators, we can easily sort our lists based on various criteria. Remember to consider the trade-offs between different collections and choose the one that best fits your specific use case. Happy sorting!