A lambda expression is a short block
of code which takes in parameters
and returns a value. Lambda expressions
are similar to methods, but they do
not need a name and they can be
implemented right in the body of a method.
parameter -> expression
To use more than one parameter, wrap them in parentheses:
(parameter1, parameter2) -> expression
Example
Use a lamba expression in the ArrayList's
forEach() method to print every item in the list:
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> numbers = new ArrayList<Integer>();
numbers.add(5);
numbers.add(9);
numbers.add(8);
numbers.add(1);
numbers.forEach( (n) -> { System.out.println(n); } );
}
}
interface demoLambda{
void sayHello();
}
public class main(String[]args){
demoLambda(()->System.out.println("hello"));
}
public void demoLambda(demoLambda d){
d.sayhello();
}
//* No Parameter Syntax
() -> {
//Body of no parameter lambda
}
//* One Parameter Syntax
(p1) -> {
//Body of single parameter lambda
}
There are few functional interfaces namely Consumer, Supplier, Predicate and Functions
- Consumer:
+ 1 input, 0 output
+ java.util.function.Consumer
+ example: Consumer<List<String>> printConsumer = list -> list.stream().forEach(System.out::println);
- Supplier:
+ 0 input, 1 output
+ java.util.function.Supplier
+ example: Supplier<Double> doubleSupplier1 = () -> Math.random();
- Predicate:
+ 1 input, 1 boolean output
+ java.util.function.Predicate
+ example: Predicate<String> nameStartsWithS = str -> str.startsWith("S");
- Function:
+ 1 input, 1 output
+ java.util.function.Function
+ example: Function<String, Integer> nameMappingFunction = String::length;
public class TestLambda {
public static void main(String args[]) {
List<String> lowerCaseStringsList = Arrays.asList("a","b","c");
// the :: notation is the lambda expression
// it's the same as the anonymous function s -> s.toUpperCase()
List<String> upperCaseStringsList = lowerCaseStringsList.stream().
map(String::toUpperCase).
collect(Collectors.toList());
}
}
StateOwner stateOwner = new StateOwner();
stateOwner.addStateListener(
(oldState, newState) -> System.out.println("State changed")
);
static int method(IntBinaryOperator op){
return op.applyAsInt(5, 10);
}
//The:
Runnable r = ()-> System.out.print("Run method");
//is equivalent to:
Runnable r = new Runnable() {
@Override
public void run() {
System.out.print("Run method");
}
};
(par1, par2, ...) -> {do...}