Java 8 – BiFunction Functional Interface

In this article, we will discuss pre-defined Functional Interface in Java 1.8 version for performing operation based on 2 input arguments and returning results after computation/processing i.e.; BiFunction Functional Interface

1. BiFunction Functional Interface:

• This Functional Interface has one abstract method called R apply(T t, U u); which
• Step 1 :- accepts 2 input arguments of any data-type
• Step 2 :- performs some operation on the 2 input arguments
• Step 3 :- And return result of any data-type
• Below is the BiFunction Functional interface containing apply(); method along with other default & static methods
• Note: BiFunction is exactly same as that of Function Functional Interface except that it accepts 2 input arguments whereas Function accepts single argument

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface BiFunction<T, U, R> {

    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    R apply(T t, U u);
    
    // other default and static methods
}

2. Examples for BiFunction Functional Interface:

Example 1 – program to create Student Object based on input arguments supplied/passed to lambda expression

package net.bench.resources.bifunction.example;

import java.util.function.BiFunction;

class Student {

	// member variables
	String name;
	int rollno;

	// public constructor
	public Student(String name, int rollno) {
		super();
		this.name = name;
		this.rollno = rollno;
	}
}

public class CreateStudentObject {

	public static void main(String[] args) {

		// lambda expression to create Student object using BiFunction FI
		BiFunction<String, Integer, Student> bf = (name, rollno) -> new Student(name, rollno);

		// create Student object by invoking above lambda expression
		Student s = bf.apply("Ashwin", 1002);

		// printing student info
		System.out.println("Name     : " + s.name);
		System.out.println("Roll No. : " + s.rollno);
	}
}

Output:

Name     : Ashwin
Roll No. : 1002

Example 2 – program to create a ArrayList of Student Objects

package net.bench.resources.bifunction.example;

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiFunction;

class Student {

	// member variables
	String name;
	int rollno;

	// public constructor
	public Student(String name, int rollno) {
		super();
		this.name = name;
		this.rollno = rollno;
	}
}

public class ListOfStudentObjects {

	public static void main(String[] args) {

		// lambda expression to create Student object using BiFunction FI
		BiFunction<String, Integer, Student> bf = (name, rollno) -> new Student(name, rollno);

		// create ArrayList object to store of Student objects
		List<Student> students = new ArrayList<>();

		// add Student object to List by invoking above lambda expression
		students.add(bf.apply("Warne", 1001));
		students.add(bf.apply("Murali", 1002));
		students.add(bf.apply("Kumble", 1003));
		students.add(bf.apply("Vettori", 1004));
		students.add(bf.apply("Saqlain", 1005));

		// printing student info by iterating
		for(Student student : students) {

			// print info
			System.out.println("Name : " + student.name + "\t Roll No. : " + student.rollno);
		}
	}
}

Output:

Name : Warne	 Roll No. : 1001
Name : Murali	 Roll No. : 1002
Name : Kumble	 Roll No. : 1003
Name : Vettori	 Roll No. : 1004
Name : Saqlain	 Roll No. : 1005

3. Difference between Function and BiFunction Functional Interface :

• Function :- It accepts 1 input argument and does some operation on the input argument passed and return value in any data-type based on the operation implemented in lambda expression
• BiFunction :- Whereas it accepts 2 input arguments and does some operation on the 2 input arguments passed and return value in any data-type based on the operation implemented in lambda expression
• So, it is simple if we want to perform some operation based on single input argument and return value then go for Function Functional Interface
• But in case if we require to do some operation on 2 input arguments and return value then BiFunction Functional Interface is the best option

package net.bench.resources.bifunction.example;

import java.util.function.BiFunction;
import java.util.function.Function;

public class DifferenceInFunctionAndBiFunction {

	public static void main(String[] args) {

		// 1. Function - lambda expression to square the input value
		Function<Integer, Integer> f = (i) -> i*i;

		// 2. BiFunction - lambda expression to add both input arguments
		BiFunction<Integer, Integer, Integer> bf = (i,j) -> (i+j);

		// 1.A test for Function
		System.out.println("Function testing : \n");

		System.out.println("1. Square of Integer 8 is \t: " + f.apply(8));

		System.out.println("2. Square of Integer 19 is \t: " + f.apply(19));

		// 2.A test for BiFunction
		System.out.println("\nBiFunction testing : \n");

		System.out.println("1. Sum of (10, 6) is \t: " + bf.apply(10, 6));

		System.out.println("2. Sum of (7, 3) is \t: " + bf.apply(7, 3));
	}
}

Output:

Function testing : 

1. Square of Integer 8 is 	: 64
2. Square of Integer 19 is 	: 361

BiFunction testing : 

1. Sum of (10, 6) is 	: 16
2. Sum of (7, 3) is 	: 10

References:

• https://docs.oracle.com/javase/8/docs/api/java/util/function/BiFunction.html
• https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html
• https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html
• https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Happy Coding !!
Happy Learning !!