Home » Java » Core Java » How many lines of code did you write to sort a collection of objects before Java 8 ?

About Semika Kaluge

Semika Kaluge
I am working in software engineering field for six years of time by now. Currently, I am working for Shipxpress Inc in Sri Lanka. Primarily, I love to involve with Java developments and related frameworks like Spring, Struts, Hibernate and many more, specially interested in Javascript.

How many lines of code did you write to sort a collection of objects before Java 8 ?

How many lines of code did you write to sort a collection of objects before Java 8 ? How many, you will need with Java 8 ?

You can do it with a single line in Java 8.

Let’s see the following Employee class.

public class Employee {
 
     private String name;
 
     private Integer age;
 
     public Employee(String name, Integer age) {
         super();
         this.name = name;
         this.age = age;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public Integer getAge() {
         return age;
     }

     public void setAge(Integer age) {
        this.age = age;
     }

}

Using the Collection’s sort() method, employee list can be sorted. The sort() method expects a Comparator as an argument in order to compare two Employee objects. So our first solution looks like as follows.

public class EmployeeComparotor implements Comparator {
    @Override
    public int compare(Employee e1, Employee e2) {
        return e1.getAge().compareTo(e2.getAge()); 
    }
}

employeeList.sort(new EmployeeComparotor());

Rather than implementing Comparator and instantiating a new instance of it, we can use an anonymous class to improve our program.

employeeList.sort(new Comparator() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return e1.getAge().compareTo(e2.getAge()); 
    }
});

Now, let’s see, how can we improve this code further in order to reduce the verbosity by using Java 8 features. Java 8 introduces lambda expressions which allows us to pass a code to a method. Lambda expression can be passed to a method where functional interface is expected. A functional interface is an interface defining only one abstract method. In Java 8, the Comparator is a functional interface. The Collection’s sort() method expects a Comparator as an argument, which accepts a functional interface. In this case, the Comparator represents BiFunction’s descriptor. The BiFunction is a functional interface in Java 8. So then, you can pass a lambda expression into the sort method as follows. In order to sort employee list by their age, you need a single line as follows.

employeeList.sort((Employee e1, Employee e2) -> e1.getAge().compareTo(e2.getAge()));

Java compiler can infer the types of parameters of a lambda expression by using the context in which the lambda appears. So you can remove the types of parameter and rewrite the code as follows.

employeeList.sort((e1, e2) -> e1.getAge().compareTo(e2.getAge()));

Let’s try to further reduce the code. Java 8 Comparator has a static method called comparing() that accepts a Function as an argument. This Function should extract the sort key and produce a Comparator object. So the shortest code to sort a list of objects in Java 8 will be,

employeeList.sort(comparing((e) -> e1.getAge()));

In stead of using a lambda expression, we can use method references to make our code slightly less verbose.

employeeList.sort(comparing(Employee::getAge));

If you want to sort the employee list by descending order in age, you can use the reversed() default method of the interface.

employeeList.sort(comparing(Employee::getAge).reversed());

Now, let’s see, you want to sort the employees in their age and then, similar age employees by their names. Just remind, how did you do this earlier version of Java. In Java 8, you can simply use thenComparing() method in order to do this.

employeeList.sort(comparing(Employee::getAge).thenComparing(Employee::getName));
Published on Java Code Geeks with permission by Semika Kaluge, partner at our JCG program. See the original article here: How many lines of code did you write to sort a collection of objects before Java 8 ?

Opinions expressed by Java Code Geeks contributors are their own.

(+1 rating, 1 votes)
You need to be a registered member to rate this.
Start the discussion Views Tweet it!
Do you want to know how to develop your skillset to become a Java Rockstar?
Subscribe to our newsletter to start Rocking right now!
To get you started we give you our best selling eBooks for FREE!
1. JPA Mini Book
2. JVM Troubleshooting Guide
3. JUnit Tutorial for Unit Testing
4. Java Annotations Tutorial
5. Java Interview Questions
6. Spring Interview Questions
7. Android UI Design
and many more ....
Email address:

Leave a Reply

avatar

This site uses Akismet to reduce spam. Learn how your comment data is processed.

  Subscribe  
Notify of