5.2.
BiPredicate Functional Interfaces
BiPredicate Functional Interface
o Takes Two Input Parameters
o Returns Boolean after processing.
BiPredicate Functional Interface has the following methods.
abstract boolean test(T, U);
BiPredicate<T, U> and(BiPredicate<? super T, ? super U>);
BiPredicate<T, U> negate();
BiPredicate<T, U> or(BiPredicate<? super T, ? super U>);
Demo8: Files Required:
1. Demo8.java
Demo8.java
package com.jlcindia.demos;
import java.util.function.BiPredicate;
/*
* @Author : Srinivas Dande
* @Company: Java Learning Center
* */
public class Demo8 {
public static void main(String[] args) {
BiPredicate<Integer,Integer> predicate1 = (num1,num2) -> num1>num2;
boolean mybool = predicate1.test(10,20);
System.out.println(mybool);
BiPredicate<Integer,Integer> predicate2 = (num1,num2) -> num1<num2;
mybool = predicate2.test(10,20);
System.out.println(mybool);
}
}
Java Learning Center 52 Java 8 New Features
5.3. Function Functional Interfaces
Function Functional Interface
o Takes One Input Parameter
o Returns Output after processing.
Function Functional Interface has the following methods.
abstract R apply(T); //SAM
static <T> Function<T, T> identity();
<V> Function<V, R> compose(Function<? super V, ? extends T>);
<V> Function<T, V> andThen(Function<? super R, ? extends V>);
Demo9: Files Required:
1. Demo9.java
Demo9.java
package com.jlcindia.demos;
import java.util.function.Function;
/*
* @Author : Srinivas Dande
* @Company: Java Learning Center
* */
public class Demo9 {
public static void main(String[] args) {
Function<String, String> fun1 = (input) -> input.toUpperCase();
String output1 = fun1.apply("Srinivas Dande");
System.out.println(output1);
Function<String, Integer> fun2 = (input) -> Integer.parseInt(input);
Integer output2 = fun2.apply("99");
System.out.println(output2);
Function<Integer, String> fun3 = (input) -> String.valueOf(input);
String output3 = fun3.apply(99);
System.out.println(output3);
Java Learning Center 53 Java 8 New Features
Function<String, String> fun4 = input -> input;
String output4= fun4.apply("Hello Guys");
System.out.println(output4);
Function<String, String> fun5 = Function.identity();
String output5= fun5.apply("Hello Guys");
System.out.println(output5);
}
}
Demo10: Files Required:
1. Demo10.java
Demo10.java
package com.jlcindia.demos;
import java.util.function.Function;
/*
* @Author : Srinivas Dande
* @Company: Java Learning Center
* */
public class Demo10 {
public static void main(String[] args) {
Function<Integer, Integer> fun1 = (num) -> {
System.out.println("Multiply by 2");
return num * 2;
};
Function<Integer, Integer> fun2 = (num) -> {
System.out.println("Multiply by 3");
return num * 3;
};
System.out.println(fun1.apply(5));
System.out.println(fun2.apply(5));
int result2= fun1.andThen(fun2).apply(10);
//fun1.apply(10) => 10 * 2 => 20
//fun2.apply(20) => 3 * 20 => 60
System.out.println(result2); //60
Java Learning Center 54 Java 8 New Features
int result1= fun1.compose(fun2).apply(10);
//fun2.apply(10) => 10 * 3 => 30
//fun1.apply(30) =>30 * 2 => 60
System.out.println(result1); //60
}
}
Demo11: Files Required:
1. Demo11.java
Demo11.java
package com.jlcindia.demo1;
import java.util.function.Function;
/*
* @Author : Srinivas Dande
* @Company: Java Learning Center
* */
public class Demo11 {
public static void main(String[] args) {
Function<String, Integer> fun1 = (input) -> {
System.out.println("Converting String to Integer");
return Integer.parseInt(input);
};
Function<Integer, Integer> fun2 = (num) -> {
System.out.println("add 10 to the number");
return num + 10;
};
int result2= fun1.andThen(fun2).apply("10");
System.out.println(result2); //20
int result1= fun2.compose(fun1).apply("10");
System.out.println(result1); //20
}
}
Java Learning Center 55 Java 8 New Features
5.4. UnaryOperator Functional Interfaces
UnaryOperator Functional Interface is sub type of Function which allows you specify only
One Type for both parameter and Return Value.
UnaryOperator Functional Interface
o Takes One Input Parameter
o Returns Output after processing.
UnaryOperator Functional Interface has the following methods.
abstract R apply(T); //SAM
public static <T> UnaryOperator<T> identity();
<V> Function<V, R> compose(Function<? super V, ? extends T>);
<V> Function<T, V> andThen(Function<? super R, ? extends V>);
Demo12.java
package com.jlcindia.demos;
import java.util.function.Function;
import java.util.function.UnaryOperator;
/*
* @Author : Srinivas Dande
* @Company: Java Learning Center
* */
public class Demo12 {
public static void main(String[] args) {
Function<String,String> fun1 = (input) -> input.toUpperCase();
System.out.println(fun1.apply("Hello"));
UnaryOperator<String> unary1 = (input) -> input.toUpperCase();
System.out.println(unary1.apply("Hello"));
Function<Integer, Integer> fun2 = (num) -> num * 2;
System.out.println(fun2.apply(50));
UnaryOperator<Integer> unary2 = (num) -> num * 2;
System.out.println(unary2.apply(50));
}
}
Java Learning Center 56 Java 8 New Features
5.5. BiFunction Functional Interfaces
BiFunction Functional Interface
o Takes Two Input Parameters
o Returns Output after processing.
BiFunction Functional Interface has the following methods.
abstract R apply(T, U); //SAM
<V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V>);
Demo13.java
package com.jlcindia.demos;
import java.util.function.BiFunction;
/*
* @Author : Srinivas Dande
* @Company: Java Learning Center
* */
public class Demo13 {
public static void main(String[] args) {
BiFunction<String,String,String> fun1 = (input1,input2) -> input1 + input2;
String output = fun1.apply("Hello"," Guys");
System.out.println(output);
BiFunction<Integer, Integer,Integer> fun2 = (num1,num2) -> num1 * num2;
System.out.println(fun2.apply(5,25));
BiFunction<Integer, Integer,String> fun3 = (num1,num2) -> {
int result= num1 * num2;
String str = "Result is "+result;
return str;
};
System.out.println(fun3.apply(5,25));
}
}
Java Learning Center 57 Java 8 New Features
5.6. BinaryOperator Functional Interfaces
BinaryOperator Functional Interface is sub type of BiFunction which allows you specify
only One Type for both parameter and Return Value.
BinaryOperator Functional Interface
o Takes Two Input Parameters
o Returns Output after processing.
BinaryOperator Functional Interface has the following methods.
static <T> BinaryOperator<T> minBy(Comparator<? super T>);
static <T> BinaryOperator<T> maxBy(Comparator<? super T>);
Demo14.java
package com.jlcindia.demos;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
/*
* @Author : Srinivas Dande
* @Company: Java Learning Center
* */
public class Demo14 {
public static void main(String[] args) {
BiFunction<String,String,String> fun1 = (input1,input2) -> input1 + input2;
String output = fun1.apply("Hello"," Guys");
System.out.println(output);
BinaryOperator<String> binary1 = (input1,input2) -> input1 + input2;
String output1 = binary1.apply("Hello"," Guys");
System.out.println(output1);
BiFunction<Integer, Integer,Integer> fun2 = (num1,num2) -> num1 * num2;
System.out.println(fun2.apply(5,25));
BinaryOperator<Integer> binary2 = (num1,num2) -> num1 * num2;
System.out.println(binary2.apply(5,25));
}
}
Java Learning Center 58 Java 8 New Features
5.7. Consumer and BiConsumer Interfaces
Consumer Functional Interface
o Takes One Input Parameter
o No Return Value.
Consumer Functional Interface has the following methods.
abstract void accept(T); //SAM
Consumer<T> andThen(Consumer<? super T>);
BiConsumer Functional Interface
o Takes Two Input Parameters
o No Return Value.
BiConsumer Functional Interface has the following methods.
abstract void accept(T, U);
BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U>);
Demo15.java
package com.jlcindia.demos;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
/*
* @Author : Srinivas Dande
* @Company: Java Learning Center
* */
public class Demo15 {
public static void main(String[] args) {
Consumer<String> consumer1 = (input) -> System.out.println(input.toUpperCase());
consumer1.accept("Hello");
consumer1.accept("Srinivas");
consumer1.accept("Hai");
BiConsumer<String,String> consumer2 = (input1,input2) ->
System.out.println(input1+input2);
consumer2.accept("Hello"," Guys");
}
}
Java Learning Center 59 Java 8 New Features
5.8. Supplier Functional Interfaces
Supplier Functional Interface
o Takes No Input Parameters
o Returns Any Type .
Supplier Functional Interface has the following methods.
abstract T get();
Demo16.java
package com.jlcindia.demos;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.util.function.Supplier;
/*
* @Author : Srinivas Dande
* @Company: Java Learning Center
* */
public class Demo16 {
public static void main(String[] args) {
Supplier<String> supplier1 = () -> "Hello Guys, How are you?";
String str = supplier1.get();
System.out.println(str);
Supplier<Integer> supplier2 = () -> LocalDate.now().getDayOfMonth();
System.out.println(supplier2.get());
Supplier<DayOfWeek> supplier3 = () -> LocalDate.now().getDayOfWeek();
DayOfWeek dow = supplier3.get();
System.out.println(dow);
System.out.println(dow.getValue());
}
}
Java Learning Center 60 Java 8 New Features
