Lambda
expressions basically express instances of functional interfaces (An interface
with single abstract method is called functional interface. An example is
java.lang.Runnable).
The
major benefit of java 8 functional interfaces is that we can use lambda
expressions to instantiate them and avoid using bulky anonymous class
implementation.
lambda expressions are added in Java
8 and provide below functionalities.
- Enable to treat functionality as a method argument, or code as data.
- A function that can be created without belonging to any class.
- A lambda expression can be passed around as if it was an object and executed on demand.
Example1:
package
com.dev.praticecollection;
//@FunctionalInterface
interface Processor {
String process(String str);
}
public class LambdaEx {
public static void main(String[] args) {
System.out.println(process("Hello World!", str -> str.toUpperCase()));
}
private static String process(String str, Processor processor) {
// TODO Auto-generated method stub
return processor.process(str);
}
}
|
Output:
HELLO WORLD!
Lambda Expressions syntax is (argument)
-> (body).
Method reference lets us reuse the pre-existing method
definition in
place of lambdas
Equivalent Lambda expression
String::substring
(str,i) ->str.subtring(i)
String::valueOf
number ->
String.valueOf(number)
String::new
() -> new
String()
(originalString)
-> new String (originalString)
someString::concat
(someotherString)
-> someString.concat(someotherString)
|
Example
2:
package
com.dev.praticecollection;
import
java.util.function.BiFunction;
import
java.util.function.Function;
public class LambdaEx2 {
public static void main(String[] args) {
String prefix = "MR.
";
System.out.println(process("Hello World!",
String::toUpperCase));
System.out.println(process2("Hello World!", 5, (str, i) -> str.substring(i)));
System.out.println(process("Hello World!", prefix::concat));// str -> prefix.concat(str)
}
private static String process2(String str, int i, BiFunction<String, Integer, String> processor) {
// TODO Auto-generated method stub
return processor.apply(str, i);
}
private static String process(String str, Function<String, String> processor) {
// TODO Auto-generated method stub
return processor.apply(str);
}
}
|
Output:
HELLO
WORLD!
World!
MR. Hello World!
Example 3:
If we try to modify local variable in an enclosing scope.
package
com.dev.praticecollection;
import
java.util.function.BiFunction;
import
java.util.function.Function;
public class LambdaEx2 {
public static void main(String[] args) {
String prefix = "MR.
";
System.out.println(process("Hello World!",
String::toUpperCase));
System.out.println(process2("Hello World!", 5, (str, i) -> str.substring(i)));
System.out.println(process("Hello World!", str -> {
prefix="MS
";
return prefix.concat(str);
}));// str -> prefix.concat(str)
}
private static String process2(String str, int i, BiFunction<String, Integer, String> processor) {
// TODO Auto-generated method stub
return processor.apply(str, i);
}
private static String process(String str, Function<String, String> processor) {
// TODO Auto-generated method stub
return processor.apply(str);
}
}
|
Error : Local variable prefix
defined in an enclosing scope must be final or effectively final.
Let us try to sort name using comparator without using Lambda
expression
Example 4:
package com.dev.praticecollection;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Function;
public class LambdaEx3 {
public static void main(String[] args) {
String[] names = { "Mr Sanjay", "Ms trupti", "Dr John" };
Arrays.sort(names, new Comparator<String>() {
@Override
public int compare(String name1, String name2) {
// TODO Auto-generated method stub
return name1.split(" ")[1].compareTo(name2.split(" ")[1]);
}
});
System.out.println(Arrays.toString(names));
}
private static String process(String
str,
Function<String, String> processor) {
// TODO Auto-generated method stub
return processor.apply(str);
}
}
|
Output:
[Dr John, Mr Sanjay, Ms trupti]
Example
5
Let us try to sort name using comparator with using Lambda
expression
package com.dev.praticecollection;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Function;
public class LambdaEx4 {
public
static void main(String[] args) {
String[]
names = { "Mr Sanjay", "Ms trupti", "Dr John"
};
Arrays.sort(names,(name1,
name2) ->
name1.split("
")[1].compareTo(name2.split(" ")[1])
);
System.out.println(Arrays.toString(names));
}
private static String
process(String str, Function<String, String> processor) {
// TODO
Auto-generated method stub
return
processor.apply(str);
}
}
|
Output:
[Dr John, Mr Sanjay, Ms trupti]
Example 6:
In Java
8 has static utility method to compose comparator
lambdas expression
package com.dev.praticecollection;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Function;
public class LambdaEx5 {
public
static void main(String[] args) {
String[]
names = { "Mr Sanjay", "Ms trupti", "Dr John"
};
Arrays.sort(names,
Comparator.comparing(name -> name.split(" ")[1])
);
System.out.println(Arrays.toString(names));
}
private static String
process(String str, Function<String, String> processor) {
// TODO
Auto-generated method stub
return
processor.apply(str);
}
}
|
Output:
[Dr John, Mr Sanjay, Ms trupti]
Example 7:
package com.dev.praticecollection;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Function;
public class LambdaEx5 {
public
static void main(String[] args) {
String[]
names = { "Mr Sanjay", "Ms trupti", "Dr John"
};
Arrays.sort(names,
Comparator.comparing(LambdaEx5::firstName)
);
System.out.println(Arrays.toString(names));
}
public static String
firstName(String name) {
return
name.split(" ")[1];
}
private static String
process(String str, Function<String, String> processor) {
// TODO
Auto-generated method stub
return
processor.apply(str);
}
}
|
Output:
[Dr John, Mr Sanjay, Ms trupti]
Sort the array in reverse order
Example 8:
package com.dev.praticecollection;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Function;
public class LambdaEx5 {
public
static void main(String[] args) {
String[]
names = { "Mr Sanjay", "Ms trupti", "Dr John"
};
Arrays.sort(names,
Comparator.comparing(LambdaEx5::firstName).reversed()
);
System.out.println(Arrays.toString(names));
}
public static String
firstName(String name) {
return
name.split(" ")[1];
}
private static String
process(String str, Function<String, String> processor) {
// TODO
Auto-generated method stub
return
processor.apply(str);
}
}
|
Output:
[Ms trupti, Mr Sanjay, Dr John]
Example 9:
package com.dev.praticecollection;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Function;
public class LambdaEx5 {
public
static void main(String[] args) {
String[]
names = { "Mr Sanjay", "Ms trupti", "Dr John"
};
Arrays.sort(names,
Comparator.comparing(LambdaEx5::firstName).reversed().thenComparing(LambdaEx5::title
)
);
System.out.println(Arrays.toString(names));
}
public static String
firstName(String name) {
return
name.split(" ")[1];
}
public static String
title(String name) {
return
name.split(" ")[0];
}
private static String
process(String str, Function<String, String> processor) {
// TODO
Auto-generated method stub
return
processor.apply(str);
}
}
|
Output:
[Ms trupti, Mr Sanjay, Dr John]
Posts
0 comments:
Post a Comment