Java Eight Comparator Event Using Lambda Expressions

Hello guys, After Java 8 it has acquire a lot easier to piece of occupation amongst Comparator too Comparable classes inward Java. You tin implement Comparator using lambda appear because it is a SAM type interface. It has only 1 abstract method compare() which agency y'all tin hold out past times a lambda expression where a Comparator is expected. Many Java programmer oft enquire me, what is the best way to larn lambda appear of Java 8?  And, my reply is, of course of pedagogy past times using it on your solar daytime to solar daytime programming task. Since implementing equals(), hashcode(), compareTo(), too compare() methods are about of the close mutual tasks of a Java developer, it makes feel to larn how to utilisation the lambda appear to implement Comparable and Comparator in Java.

Though, about of y'all mightiness receive got a uncertainty that, can nosotros utilisation lambda appear amongst Comparator? because it's an onetime interface too may non implement functional interface annotated with @FunctionalInterface annotation?

The reply to that inquiry is Yes, y'all tin utilisation a lambda appear to implement Comparator too Comparable interface inward Java, too non only these 2 interfaces but to implement whatever interface, which has exclusively 1 abstract method because those are known equally SAM (Single Abstract Method) Type too lambda appear inward Java supports that.

That's why lambda appear inward Java 8 is too known equally SAM type, where SAM stands for Single Abstract Method. Though, y'all should too retrieve that from Java 8 interface tin receive got non-abstract methods equally good as default and static methods.

This was 1 of the really intelligent determination made Java designers, which makes the lambdas fifty-fifty to a greater extent than useful. Because of this, y'all tin utilisation lambda expressions amongst Runnable, Callable, ActionListener, and several other existing interfaces from JDK API which has only 1 abstract method.

You should too cheque out useful Eclipse shortcuts for Java Programmers.

Even Runnable interface is too annotated with @FunctionalInterface equally seen below:

@FunctionalInterface public interface Runnable {    ....... }

but yep ActionListener is non annotated with @FunctionalInterface, but y'all tin all the same utilisation it inward lambda expressions because it only got 1 abstract method called actionPerformed()

public interface ActionListener extends EventListener {      /**      * Invoked when an activeness occurs.      */     public void actionPerformed(ActionEvent e);  }

Earlier nosotros receive got seen about hands-on examples of Java 8 Streams, hither nosotros volition larn how to utilisation lambda appear past times implementing Comparator interface inward Java. This volition brand creating custom Comparator very slow too cut lots of boilerplate code.

By the way, the From Collections to Streams inward Java 8 Using Lambda Expression course exclusively covers lambda appear too streams, it doesn't comprehend all other Java 8 features e.g. novel Date too Time API, novel JavaScript engine too other small-scale enhancements similar Base64 encoder-decoder too surgical physical care for improvements. 

For other Java 8 changes, I propose y'all to cheque out Comparator, Comparable, Runnable, Callable, ActionListener and thence on.

Earlier nosotros used to utilisation Anonymous class to implement these 1 method interfaces, to a greater extent than oft than non when nosotros desire to hold out past times them to a method or only desire to utilisation locally e.g. creating a thread for about temporary task, or treatment the event.

Now nosotros tin utilisation a lambda expression to implement these methods, In these cases, lambdas piece of occupation just similar an anonymous cast but without the heavy dose of boilerplate code required earlier equally shown inward the next diagram:

Anyway, hither is our Java plan to implement Comparator using the lambda expression inward Java 8:

import java.math.BigDecimal; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; /**  * How to variety Objects inward Java 8, past times implementing Comparator using lambda  * expression.  *  * @author WINDOWS 8  *  */ public class ComparatorUsingLambdas{      public static void main(String args[]) {          // listing of grooming courses, our target is to variety these courses         // based upon their cost or title         List<TrainingCourses> onlineCourses = new ArrayList<>();         onlineCourses.add(new TrainingCourses("Java", new BigDecimal("200")));         onlineCourses.add(new TrainingCourses("Scala", new BigDecimal("300")));         onlineCourses.add(new TrainingCourses("Spring", new BigDecimal("250")));         onlineCourses.add(new TrainingCourses("NoSQL", new BigDecimal("310")));           // Creating Comparator to compare Price of grooming courses         final Comparator<TrainingCourses> PRICE_COMPARATOR = new Comparator<TrainingCourses>() {             @Override             public int compare(TrainingCourses t1, TrainingCourses t2) {                 return t1.price().compareTo(t2.price());             }         };           // Comparator to compare championship of courses         final Comparator<TrainingCourses> TITLE_COMPARATOR = new Comparator<TrainingCourses>() {             @Override             public int compare(TrainingCourses c1, TrainingCourses c2) {                 return c1.title().compareTo(c2.title());             }         };           // sorting objects using Comparator past times price         System.out.println("List of grooming courses, earlier sorting");         System.out.println(onlineCourses);         Collections.sort(onlineCourses, PRICE_COMPARATOR);                 System.out.println("After sorting past times price, increasing order");         System.out.println(onlineCourses);         System.out.println("Sorting listing past times championship ");              Collections.sort(onlineCourses, TITLE_COMPARATOR);         System.out.println(onlineCourses);           // Now let's run across how less code y'all demand to write if y'all use         // lambda appear from Java 8, inward house of anonymous class         // nosotros don't demand an extra draw of piece of occupation to declare comparator, nosotros can         // render them inward house to sort() method.                   System.out.println("Sorting objects inward decreasing lodge of price, using lambdas");         Collections.sort(onlineCourses, (c1, c2) -> c2.price().compareTo(c1.price()));         System.out.println(onlineCourses);                 System.out.println("Sorting listing inward decreasing lodge of title, using lambdas");         Collections.sort(onlineCourses, (c1, c2) -> c2.title().compareTo(c1.title()));         System.out.println(onlineCourses);     } }  class TrainingCourses {     private final String title;     private final BigDecimal price;      public TrainingCourses(String title, BigDecimal price) {         super();         this.title = title;         this.price = price;     }      public String title() {         return title;     }      public BigDecimal price() {         return price;     }      @Override     public String toString() {         return String.format("%s : %s", title, price);     } }  Output: List of grooming courses, earlier sorting [Java : 200, Scala : 300, Spring : 250, NoSQL : 310] After sorting past times price, increasing lodge [Java : 200, Spring : 250, Scala : 300, NoSQL : 310] Sorting listing past times championship [Java : 200, NoSQL : 310, Scala : 300, Spring : 250] Sorting objects inward decreasing lodge of price, using lambdas [NoSQL : 310, Scala : 300, Spring : 250, Java : 200] Sorting listing inward decreasing lodge of title, using lambdas [Spring : 250, Scala : 300, NoSQL : 310, Java : 200]

In this example, nosotros receive got an object called TrainingCourse, which stand upwardly for a typical grooming course of pedagogy from institutes. For simplicity, it only got 2 attributes championship too price, where the championship is String and cost is BigDecimal because float too double are non practiced for exact calculations.

Now nosotros receive got a listing of grooming courses too our chore is to variety based on their cost or based upon their title. Ideally, TrainingCourse class should implement the Comparable interface too variety grooming courses past times their title, i.e. their natural order.

Anyway, nosotros are non doing that hither to focus purely on Comparator.

To consummate these chore nosotros demand to create 2 custom Comparator implementation, 1 to sort TrainingCourse by championship too other to variety it past times price.

To demo the stark departure inward the release of lines of code y'all demand to do this prior to Java 8 too inward JDK 1.8, I receive got implemented that 2 Comparator outset using Anonymous class and afterwards using the lambda expression.

You tin run across that past times using lambdas implementing Comparator just accept 1 draw of piece of occupation too y'all tin fifty-fifty do that on method invocation, without sacrificing readability.

This is the top dog reason, why y'all should utilisation the lambda appear to implement Comparator, Runnable, Callable or ActionListener post-Java 8, they brand your code to a greater extent than readable too terse.

For a consummate Java 8 learning, I recommend The Complete Java MasterClass course on Udemy. It is too the close up-to-date course of pedagogy too of late updated for Java 11.

Implement Comparator using Method References inward Java 8

By the way, y'all tin fifty-fifty do amend past times leveraging novel methods added on Comparator interface inward Java 8 too past times using method references equally shown below:

You tin run across that past times using novel methods inward Comparator similar comparing()  too method references, y'all tin implement Comparator inward only 1 draw of piece of occupation after Java 8 version. I strongly recommend this manner of code inward electrical current Java word.


That's all on how to implement Comparator using Java 8 lambda expression. You tin run across it accept really less code to create custom Comparator using lambdas than anonymous class. From Java 8 at that topographic point is no indicate using anonymous cast anymore, inward fact, utilisation lambdas wherever y'all used to utilisation Anonymous class.  Make certain y'all implement SAM interfaces using lambdas e.g. Runnable, Callable, ActionListener etc. If y'all desire to larn Java 8, too then y'all tin too refer to the next resources:


Further Learning
The Complete Java MasterClass
The Ultimate Java 8 Tutorial
tutorial)

What is the default method inward Java 8? (example)

How to utilisation filter() method inward Java 8 (tutorial)

How to variety the map past times keys inward Java 8? (example)

5 Books to Learn Java 8 from Scratch (books)

How to utilisation Stream cast inward Java 8 (tutorial)

How to convert List to Map inward Java 8 (solution)

How to bring together String inward Java 8 (example)

Difference betwixt abstract cast too interface inward Java 8? (answer)

10 Free Courses for Experienced Java Programmers (courses)

How to utilisation peek() method inward Java 8 (example)

How to variety the may past times values inward Java 8? (example)

How to format/parse the engagement amongst LocalDateTime inward Java 8? (tutorial)

5 Free Courses to larn Java 8 too ix (courses)

Thanks for reading this article thence far. If y'all similar this article too then delight percentage amongst your friends too colleagues. If y'all receive got whatever questions or suggestions too then delight drib a note.