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.
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
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();