Java 8 Lambda Expressions
Download as PPTX, PDF2 likes765 views
The document discusses Java 8 features such as lambda expressions, which simplify the implementation of functional interfaces, and the introduction of default and static methods within interfaces. It covers the use of anonymous inner classes, method references, and streams for aggregate operations on collections. Examples are provided to illustrate how lambda expressions can replace traditional anonymous classes for more concise and readable code.
Java 8 Lambda Expressions
- 2. INTERFACES IN JAVA 8 • In JAVA 8, the interface body can contain • Abstract methods • Static methods • Default methods • Example public interface SampleIface { public void process(); public static void print(){ System.out.println("Static Method In Interface"); } public default void apply(){ System.out.println("Default Metod In Interface"); } }
- 3. FUNCTIONAL INTERFACE • java.lang.Runnable, java.awt.event.ActionListener, java.util.Comparator, java.util.concurrent.Callable … etc ; • There is some common feature among the stated interfaces and that feature is they have only one method declared in their interface definition • These interfaces are called Single Abstract Method interfaces (SAM Interfaces) • With Java 8 the same concept of SAM interfaces is recreated and are called Functional interfaces • There’s an annotation introduced- @FunctionalInterface which can be used for compiler level errors when the interface you have annotated is not a valid Functional Interface.
- 4. EXAMPLE @FunctionalInterface public interface Predicate<T> { boolean test(T t); default Predicate<T> and(Predicate<? super T> other) { ------SOME CODE-------- } default Predicate<T> negate() { ------SOME CODE-------- } default Predicate<T> or(Predicate<? super T> other) { ------SOME CODE-------- } static <T> Predicate<T> isEqual(Object targetRef) { ------SOME CODE-------- } }
- 5. ANONYMOUS INNER CLASSES • An interface that contains only one method, then the syntax of anonymous classes may seem unwieldy and unclear. • We're usually trying to pass functionality as an argument to another method, such as what action should be taken when someone clicks a button. okButton.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { System.out.println("OK Button Clicked"); } });
- 6. LAMBDA • Lambda expressions enable us to treat functionality as method argument, or code as data • Lambda expressions let us express instances of single-method classes more compactly. • A lambda expression is composed of three parts. Argument List Arrow Token Body (int x, int y) -> x + y
- 7. okButton.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { System.out.println("OK Button Clicked"); } }); okButton.addActionListener((ActionEvent e) -> { System.out.println("OK Button Clicked - 2"); }); okButton.addActionListener( (ActionEvent e) -> System.out.println("OK Button Clicked")); okButton.addActionListener(e -> System.out.println("OK Button Clicked")); Equivalent Lambda expression EXAMPLE
- 8. EXAMPLE new Thread(new Runnable() { @Override public void run() { for (int i=1;i<=10;i++){ System.out.println("i = " + i); } } }).start(); Equivalent Lambda expression new Thread(() -> { for (int i=1;i<=10;i++){ System.out.println("i = " + i); } }).start();
- 9. EXAMPLE Collections.sort(employeeList, new Comparator<Employee>() { @Override public int compare(Employee e1, Employee e2) { return e1.getEmpName().compareTo(e2.getEmpName()); } }); Equivalent Lambda expression Collections.sort(employeeList, (e1, e2) -> e1.getEmpName().compareTo(e2.getEmpName()));
- 10. EXAMPLE Collections.sort(employeeList, (e1, e2) -> e1.getEmpName().compareTo(e2.getEmpName())); Collections.sort(employeeList, (Employee e1, Employee e2) -> e1.getEmpName().compareTo(e2.getEmpName())); Collections.sort(employeeList, (e1, e2) -> { return e1.getEmpName().compareTo(e2.getEmpName()); }); Collections.sort(employeeList, (Employee e1, Employee e2) -> { return e1.getEmpName().compareTo(e2.getEmpName()); });
- 11. METHOD REFERENCES • Sometimes a lambda expression does nothing but call an existing method • In those cases, it's often clearer to refer to the existing method by name • Method references enable you to do this; they are compact, easy-to-read lambda expressions for methods that already have a name. • Different kinds of method references: Kind Example Reference to a static method ContainingClass::staticMethodName Reference to an instance method of a particular object containingObject::instanceMethodName Reference to a constructor ClassName::new
- 12. REFERENCE TO A STATIC METHOD public class Person { private String firstName; private String lastName; private Calendar birthday; //GETTERS & SETTERS public static int compareByAge(Person a, Person b) { return a.getBirthday().compareTo(b.getBirthday()); } } Collections.sort(personList, (p1,p2) -> Person.compareByAge(p1, p2)); Lambda expression Equivalent Method Reference Collections.sort(personList, Person::compareByAge);
- 13. REFERENCE TO AN INSTANCE METHOD public class ComparisonProvider { public int compareByName(Person a, Person b) { return a.getFirstName().compareTo(b.getFirstName()); } public int compareByAge(Person a, Person b) { return a.getBirthday().compareTo(b.getBirthday()); } } ComparisonProvider comparisonProvider = new ComparisonProvider(); Collections.sort(personList, (p1,p2) -> comparisonProvider.compareByName(p1, p2)); Lambda expression Collections.sort(personList, comparisonProvider::compareByName); Equivalent Method Reference
- 14. REFERENCE TO A CONSTRUCTOR public static void transfer(Map<String, String> source, Supplier<Map<String, String>> mapSupplier){ // code to transfer } Anonymous Inner Class transfer(src, new Supplier<Map<String, String>>() { @Override public Map<String, String> get() { return new HashMap<>(); } }); Lambda expression transfer(src, () -> new HashMap<>()); Equivalent Method Reference transfer(src, HashMap::new);
- 15. AGGREGATE OPERATIONS IN COLLECTIONS • Streams • A stream is a sequence of elements. Unlike a collection, it is not a data structure that stores elements. • Pipelines • A pipeline is a sequence of aggregate operations. • PIPELINE contains the following • A Source • Zero or more intermediate operations • A terminal operation
- 16. EXAMPLE List<Employee> employeeList = new ArrayList<>(); //Add elements into employee list. employeeList .stream() .filter(employee -> employee.getGender() == Person.Sex.FEMALE) .forEach(employee -> System.out.println(employee)); int totalAge = employeeList .stream() .mapToInt(Person::getAge) .sum(); double average = employeeList .stream() .filter(p -> p.getGender() == Person.Sex.MALE) .mapToInt(Person::getAge) .average() .getAsDouble();