Function Interface is a predefined functional interface introduced in Java 8. If we can give some input then perform some operation on that given input and provide a corresponding output. We don’t want to conditional check but we need some business logic.
Like: Given input 4 —-> square(4) —–>16
So, our requirement is business functionality whenever we can provide input and perform some operation then the corresponding output is provided then we can use the “Function” predefined functional interface.
Prototype:
interface Function<T , R>{
public R apply(T t);
}
Type Parameters:
T – It is a type of input to the function
R – It is a type of result of the function
Example:
import java.util.function.Function;
public class Test {
public static void main(String[] args) {
Function<Integer, Integer> f = s -> s * s;
System.out.println("Square Of No.:" + f.apply(4));
System.out.println("Square Of No.:" + f.apply(5));
}
}
→ In the above we can achieve the square of a given number task.
→ We analyzed the lines of code concisely by using the “Function” functional interface.
Output:
Square Of No.:16
Square Of No.:25
Example:
import java.util.function.Function;
public class Test {
public static void main(String[] args) {
Function<String, Integer> f = s -> s.length();
System.out.println("Square Of No.:" + f.apply("Functional Interface"));
}
}
→ In the above example, we gave input as a String and performed an operation i.e., calculate a String length business logic and provide the result of the length of a String.
Output:
Square Of No.:20
Example:
import java.util.function.Function;
class Student {
String name;
int marks;
public Student(String name, int marks) {
this.name = name;
this.marks = marks;
}
}
public class Test {
public static void main(String[] args) {
Function < Student, String > f = stdnt -> {
int marks = stdnt.marks;
String grades = "";
if (marks >= 90)
grades = "A+";
else if (marks >= 80)
grades = "A";
else if (marks >= 70)
grades = "B+";
else if (marks >= 60)
grades = "B";
else if (marks >= 50)
grades = "C";
else if (marks >= 40)
grades = "D";
else
grades = "E";
return grades;
};
Student[] s = {
new Student("Raghav", 100),
new Student("Raj", 80),
new Student("Varun", 70),
new Student("Vikas", 60),
new Student("Manav", 50),
new Student("Dinesh", 40),
new Student("Deepak", 30)
};
for (Student s1: s) {
System.out.println("Student Name:" + s1.name);
System.out.println("Student Marks:" + s1.marks);
System.out.println("Student Grade:" + f.apply(s1));
System.out.println("------------------------------");
}
}
}
→ In the above we can use our own class type input in the “Function” functional interface.
Output:
Student Name:Raghav
Student Marks:100
Student Grade:A+
------------------------------
Student Name:Raj
Student Marks:80
Student Grade:A
------------------------------
Student Name:Varun
Student Marks:70
Student Grade:B+
------------------------------
Student Name:Vikas
Student Marks:60
Student Grade:B
------------------------------
Student Name:Manav
Student Marks:50
Student Grade:C
------------------------------
Student Name:Dinesh
Student Marks:40
Student Grade:D
------------------------------
Student Name:Deepak
Student Marks:30
Student Grade:E
------------------------------
Function Chaining:
Two Functions combined together to perform a complex operation are called “Function Chaining”.
f1.andThen(f2).apply(i); //first f1 followed by f2
f1.compose(f2).apply(i); //first f2 and then f1
Example:
import java.util.function.Function;
public class Test {
public static void main(String[] args) {
Function < Integer, Integer > f1 = i -> 2 * i;
Function < Integer, Integer > f2 = i -> i * i * i;
System.out.println(f1.andThen(f2).apply(2));
System.out.println(f1.compose(f2).apply(2));
}
}
→ f1.andThen(f2).apply(2): In this case, f1 apply first then f2 is applied (i.e., 2*2=4 and then 4*4*4=64).
→ f1.compose(f2).apply(2): In this case f2 applies first then f1 is applied (i.e., 2*2*2=8 and then 2*8=16).
Output:
64
16
Conclusion:
This example is explained What is the Function predefined functional interface? How to use this Function functional interface? What is the Function of chaining? How to use Function chaining?