Java Eight Comparator Event Using Lambda Expressions

Hello guys, After Java 8 it has conk a lot easier to piece of occupation amongst Comparator as well as Comparable classes inwards Java. You tin implement Comparator using lambda aspect because it is a SAM type interface. It has but i abstract method compare() which agency you lot tin hold upwards past times a lambda expression where a Comparator is expected. Many Java programmer ofttimes inquire me, what is the best way to larn lambda aspect of Java 8?  And, my respond is, of course of report past times using it on your solar daytime to solar daytime programming task. Since implementing equals(), hashcode(), compareTo(), as well as compare() methods are unopen to of the virtually mutual tasks of a Java developer, it makes feel to larn how to utilisation the lambda aspect to implement Comparable and Comparator in Java.

Though, unopen to of you lot mightiness receive got a dubiety that, can nosotros utilisation lambda aspect amongst Comparator? because it's an onetime interface as well as may non implement functional interface annotated with @FunctionalInterface annotation?

The respond to that inquiry is Yes, you lot tin utilisation a lambda aspect to implement Comparator as well as Comparable interface inwards Java, as well as non but these 2 interfaces but to implement whatever interface, which has solely i abstract method because those are known every bit SAM (Single Abstract Method) Type as well as lambda aspect inwards Java supports that.

That's why lambda aspect inwards Java 8 is likewise known every bit SAM type, where SAM stands for Single Abstract Method. Though, you lot should likewise hollo upwards that from Java 8 interface tin receive got non-abstract methods every bit good as default and static methods.

This was i of the real intelligent determination made Java designers, which makes the lambdas fifty-fifty to a greater extent than useful. Because of this, you lot tin utilisation lambda expressions amongst Runnable, Callable, ActionListener, and several other existing interfaces from JDK API which has but i abstract method.

You should likewise banking concern jibe out useful Eclipse shortcuts for Java Programmers.

Even Runnable interface is likewise annotated with @FunctionalInterface every bit seen below:

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

but aye ActionListener is non annotated with @FunctionalInterface, but you lot tin withal utilisation it inwards lambda expressions because it but got i abstract method called actionPerformed()

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

Earlier nosotros receive got seen unopen to hands-on examples of Java 8 Streams, hither nosotros volition larn how to utilisation lambda aspect past times implementing Comparator interface inwards Java. This volition brand creating custom Comparator very tardily as well as cut back lots of boilerplate code.

By the way, the From Collections to Streams inwards Java 8 Using Lambda Expression course solely covers lambda aspect as well as streams, it doesn't encompass all other Java 8 features e.g. novel Date as well as Time API, novel JavaScript engine as well as other modest enhancements similar Base64 encoder-decoder as well as surgical procedure improvements. 

For other Java 8 changes, I propose you lot to banking concern jibe out Comparator, Comparable, Runnable, Callable, ActionListener and hence on.

Earlier nosotros used to utilisation Anonymous class to implement these i method interfaces, by as well as large when nosotros desire to hold upwards past times them to a method or but desire to utilisation locally e.g. creating a thread for unopen to temporary task, or treatment the event.

Now nosotros tin utilisation a lambda expression to implement these methods, In these cases, lambdas piece of occupation precisely similar an anonymous degree but without the heavy dose of boilerplate code required earlier every bit shown inwards the next diagram:

Anyway, hither is our Java programme to implement Comparator using the lambda expression inwards Java 8:

import java.math.BigDecimal; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; /**  * How to kind Objects inwards Java 8, past times implementing Comparator using lambda  * expression.  *  * @author WINDOWS 8  *  */ public class ComparatorUsingLambdas{      public static void main(String args[]) {          // listing of preparation courses, our target is to kind 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 preparation 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 preparation 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 into how less code you lot demand to write if you lot use         // lambda aspect from Java 8, inwards house of anonymous class         // nosotros don't demand an extra business to declare comparator, nosotros can         // supply them inwards house to sort() method.                   System.out.println("Sorting objects inwards decreasing fellowship of price, using lambdas");         Collections.sort(onlineCourses, (c1, c2) -> c2.price().compareTo(c1.price()));         System.out.println(onlineCourses);                 System.out.println("Sorting listing inwards decreasing fellowship 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 preparation courses, earlier sorting [Java : 200, Scala : 300, Spring : 250, NoSQL : 310] After sorting past times price, increasing fellowship [Java : 200, Spring : 250, Scala : 300, NoSQL : 310] Sorting listing past times championship [Java : 200, NoSQL : 310, Scala : 300, Spring : 250] Sorting objects inwards decreasing fellowship of price, using lambdas [NoSQL : 310, Scala : 300, Spring : 250, Java : 200] Sorting listing inwards decreasing fellowship of title, using lambdas [Spring : 250, Scala : 300, NoSQL : 310, Java : 200]

In this example, nosotros receive got an object called TrainingCourse, which correspond a typical preparation course of report from institutes. For simplicity, it but got 2 attributes championship as well as price, where the championship is String and cost is BigDecimal because float as well as double are non expert for exact calculations.

Now nosotros receive got a listing of preparation courses as well as our chore is to kind based on their cost or based upon their title. Ideally, TrainingCourse class should implement the Comparable interface as well as kind preparation 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, i to sort TrainingCourse by championship as well as other to kind it past times price.

To demonstrate the stark departure inwards the publish of lines of code you lot demand to practice this prior to Java 8 as well as inwards JDK 1.8, I receive got implemented that 2 Comparator starting fourth dimension using Anonymous class and later on using the lambda expression.

You tin run into that past times using lambdas implementing Comparator just accept i business as well as you lot tin fifty-fifty practice that on method invocation, without sacrificing readability.

This is the primary reason, why you lot should utilisation the lambda aspect to implement Comparator, Runnable, Callable or ActionListener post-Java 8, they brand your code to a greater extent than readable as well as terse.

For a consummate Java 8 learning, I recommend The Complete Java MasterClass course on Udemy. It is likewise the virtually up-to-date course of report as well as of late updated for Java 11.

Implement Comparator using Method References inwards Java 8

By the way, you lot tin fifty-fifty practice improve past times leveraging novel methods added on Comparator interface inwards Java 8 as well as past times using method references every bit shown below:

You tin run into that past times using novel methods inwards Comparator similar comparing()  as well as method references, you lot tin implement Comparator inwards but i business after Java 8 version. I strongly recommend this mode of code inwards electrical current Java word.


That's all on how to implement Comparator using Java 8 lambda expression. You tin run into it accept real less code to create custom Comparator using lambdas than anonymous class. From Java 8 in that place is no indicate using anonymous degree anymore, inwards fact, utilisation lambdas wherever you lot used to utilisation Anonymous class.  Make certain you lot implement SAM interfaces using lambdas e.g. Runnable, Callable, ActionListener etc. If you lot desire to larn Java 8, as well as hence you lot tin likewise refer to the next resources:


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

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

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

How to kind the map past times keys inwards Java 8? (example)

5 Books to Learn Java 8 from Scratch (books)

How to utilisation Stream degree inwards Java 8 (tutorial)

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

How to bring together String inwards Java 8 (example)

Difference betwixt abstract degree as well as interface inwards Java 8? (answer)

10 Free Courses for Experienced Java Programmers (courses)

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

How to kind the may past times values inwards Java 8? (example)

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

5 Free Courses to larn Java 8 as well as ix (courses)

Thanks for reading this article hence far. If you lot similar this article as well as hence delight portion amongst your friends as well as colleagues. If you lot receive got whatever questions or suggestions as well as hence delight drib a note.

Share this post