lambda expression is a function:
(parameters) -> expression
or
(parameters) -> { statements; }
1. (int x, int y) -> x + y // takes two integers and returns their sum
2. (x, y) -> x - y // takes two numbers and returns their difference
3. () -> 42 // takes no values and returns 42
4. (String s) -> System.out.println(s)
// takes a string, prints its value to the console, and returns nothing
5. x -> 2 * x // takes a number and returns the result of doubling it
6. c -> { int s = c.size(); c.clear(); return s; } // takes a collection, clears it, and returns its previous size
Functional interfaces have a
single functionality to exhibit. For example, a Comparable interface with a single method 'compareTo' is used for comparison purpose. Java 8 has defined a lot of functional interfaces to be used extensively in lambda expressions.
IntOperation is a functional interface since it contain single method.
interface IntOperation { int operate(int i); }
IntOperation iop = x -> x * 2;
System.out.println(iop.operate(5));
class Bar { int i; Foo foo = i -> i * 2; }; //member variable - leagal
void bar() { int i; Foo foo = i -> i * 2; }; // local variable Illegal: variable i is already defined
UnaryOperator
factorial = i -> i == 0 ? 1 : i * factorial.apply( i - 1 ); Runnable r = () -> {System.out.println("Hello World");};
new Thread(r).start();
Referance : (::)
1. static method referance (Type :: Method Name)
2.instant method referance (Type :: Method Name)
2. construtor method referance (Type :: New)
Method references are handles to such existing methods.
String::valueOf
Integer::compare
ReferenceType::Identifier
Constructor references are created using syntax similar to that for method references, but with the method name replaced with the keyword new
List
strList = Arrays.asList("1","2","3"); List
intList = strList.stream().map(Integer::new).collect(Collectors.toList()); System.out.println(intList);
Default Methods ::
declare concrete methods in the form of default implementations.
public interface Sized {
public default boolean isEmpty() {
return size() == 0;
}
public int size();
}
most specific default-providing interface is selected. interface A{ public default boolean isEmpty() { return true; } }
interface B{ public default boolean isEmpty() { return true; } }
public class HelloWorld implements A,B-> //Compilation Error
interface A { default void hello() { System.out.println("Hello World from A"); }}
interface B extends A { default void hello() { System.out.println("Hello World from B"); } //Override Here - since its most specific }
public class HelloWorld implements B,A{ No Compilation error // B will be printed
Diamond problem // - No Compilation Error
interface A { default void m() {} ;}
interface B extends A {}
interface C extends A {}
public class HelloWorld implements B,C{
interface A { default void m() {} ;}
interface B extends A { default void m() {} ; }
interface C extends A { default void m() {} ; }
public class HelloWorld implements B,C{ // Compilation Error
interface A { default void m() {} ;}
interface B extends A { }
interface C extends A { default void m() {} ; }
public class HelloWorld implements B,C{ //No Compilation Error
interface A { default void m() {} ;}
interface B extends A { default void m() {} ; }
interface C extends A { }
public class HelloWorld implements B,C{ // No - Compilation Error
interface A {default void m() { System.out.println("hello from A"); } }
IntStream.range(0, 5(Count)).forEach(i -> A.m()); // 5 times m method will be printed
void repeat(int count, Runnable action) {
IntStream.range(0, count).forEach(i -> action.run());
}
repeat(3, () -> System.out.println("Hello!"));
List
list = new ArrayList<>();iterator.forEachRemaining(list::add);
A stream is a sequence of values. The package java.util.stream
filter
Predicate
T ➞ boolean Stream stream containing input elements that satisfy the Predicatemap
Function
T ➞ R Stream stream of values, the result of applying the Function to each input elementsorted
Comparator
(T, T) ➞ int Stream stream containing the input elements, sorted by the Comparatorlimit, skip
Stream
stream including only (resp. skipping) first n input elementssample eager/terminal operations
reduce
BinaryOperator
(T, T) ➞ T Optional result of reduction of input elements (if any) using supplied BinaryOperatorfindFirst
Predicate
T ➞ boolean Optional first input element satisfying Predicate (if any)forEach
Consumer
T ➞ void void void, but applies the method of supplied Consumer to every input element
