Java 8 – Primitive BiFunction Functional Interface

May 1, 2020 SJ Java 8 0

In this article, we will discuss different variation of pre-defined BiFunction Functional Interface available for primitive data-types like int, long, double, etc. in Java 1.8 version

Primitive BiFunction Functional Interface (return-type) :

  • This is very similar to BiFunction Functional Interface where it accepts 2 input argument of any data-type but return-type must be primitive-type like int, long and double, etc, whereas BiFunction allows to accept any data-type and return result in any data-type
  • Performance-wise primitive BiFunction is much faster compared to Function<T, U, R>
  • There are lot of conversion happening for auto-boxing & auto-unboxing for converting primitive-type to wrapper-type and again wrapper-type to primitive-type and so on
  • To avoid unnecessary conversion between primitive-type to wrapper-type and vice-versa, primitive-type specific BiFunction Functional Interface for conversion introduced in Java 1.8 version as listed below,
  1. ToIntBiFunction
  2. ToLongBiFunction
  3. ToDoubleBiFunction

We will look into method signature along with example for each one of the above primitive BiFunction Functional Interface

1. ToIntBiFunction Functional Interface

  • This primitive ToIntBiFunction Functional Interface always returns value in primitive-type int only and it is not required to declare while defining ToIntBiFunction (or lambda expression)
  • But we have to provide 2 input arguments for ToIntBiFunction<T, U> and it can be any data-type depending upon our requirement
  • Method signature: int applyAsInt(T t, U u);
package java.util.function;

@FunctionalInterface
public interface ToIntBiFunction<T, U> {

    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    int applyAsInt(T t, U u);
}

1.1 Example for ToIntBiFunction :

  • Here, while defining lambda expression using ToIntBiFunction we haven’t specified any return-type like Integer, still compiler doesn’t complain and executed well
  • And we have provided 2 input argument type as String & String for our requirement, as we are calculating to add length of both String and return result
package net.bench.resources.primitive.bifunction.example;

import java.util.function.ToIntBiFunction;

public class ToIntBiFunctionExample {

	public static void main(String[] args) {

		// lambda expression for ToIntBiFunction FI
		ToIntBiFunction<String, String> tibf = (s1, s2) -> s1.length() + s2.length();

		// test above lambda with different String

		System.out.println("1. Length of Bench and Resources is \t= "
				+ tibf.applyAsInt("Bench", "Resources"));

		System.out.println("2. Length of Oracle and Java is \t= "
				+ tibf.applyAsInt("Oracle", "Java"));

		System.out.println("3. Length of Spring and Boot is \t= "
				+ tibf.applyAsInt("Spring", "Boot"));

		System.out.println("4. Length of IBM and Redhat is \t\t= "
				+ tibf.applyAsInt("IBM", "Redhat"));

		System.out.println("5. Length of Redhat and OpenShift is \t= "
				+ tibf.applyAsInt("Redhat", "OpenShift"));
	}
}

Output:

1. Length of Bench and Resources is 	= 14
2. Length of Oracle and Java is 	= 10
3. Length of Spring and Boot is 	= 10
4. Length of IBM and Redhat is 		= 9
5. Length of Redhat and OpenShift is 	= 15

2 ToLongBiFunction Functional Interface

  • This primitive ToLongBiFunction Functional Interface always returns value in primitive-type long only and it is not required to declare while defining ToLongBiFunction (or lambda expression)
  • But we have to provide 2 input argument for ToLongBiFunction<T, U> and it can be any data-type depending upon our requirement
  • Method signature: long applyAsLong(T t, U u);
package java.util.function;

@FunctionalInterface
public interface ToLongBiFunction<T, U> {

    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    long applyAsLong(T t, U u);
}

2.1 Example for ToLongBiFunction :

  • Here, while defining lambda expression using ToLongBiFunction we haven’t specified any return-type like Long, still compiler doesn’t complain and executed well
  • And we have provided 2 input argument type as String, as we are converting into Long and then calculating average
package net.bench.resources.primitive.bifunction.example;

import java.util.function.ToLongBiFunction;

public class ToLongBiFunctionExample {

	public static void main(String[] args) {

		// lambda expression ToLongBiFunction FI

		ToLongBiFunction<String, String> tlbf = 
				(s1, s2) -> (Long.parseLong(s1) + Long.parseLong(s2)) / 2;


				// test above lambda with numbers
				System.out.println("1. Average of 5 and 7 : "
						+ tlbf.applyAsLong("5","7"));

				System.out.println("2. Average of 25 and 75 : "
						+ tlbf.applyAsLong("25","75"));

				System.out.println("3. Average of 963 and 741 : "
						+ tlbf.applyAsLong("963","741"));

				System.out.println("4. Average of 1234 and 4312 : "
						+ tlbf.applyAsLong("1234","4312"));

				System.out.println("5. Average of 54872 and 65148 : "
						+ tlbf.applyAsLong("54872","65148"));

				System.out.println("6. Average of 102365 and 95685 : "
						+ tlbf.applyAsLong("102365","956855"));
	}
}

Output:

1. Average of 5 and 7 : 6
2. Average of 25 and 75 : 50
3. Average of 963 and 741 : 852
4. Average of 1234 and 4312 : 2773
5. Average of 54872 and 65148 : 60010
6. Average of 102365 and 95685 : 529610

3 ToDoubleBiFunction Functional Interface

  • This primitive ToDoubleBiFunction Functional Interface always returns value in primitive-type double only and it is not required to declare while defining ToDoubleBiFunction (or lambda expression)
  • But we have to provide 2 input argument for ToDoubleBiFunction<T, U> and it can be any data-type depending upon our requirement
  • Method signature: double applyAsDouble(T t, U u);
package java.util.function;

@FunctionalInterface
public interface ToDoubleBiFunction<T, U> {

    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    double applyAsDouble(T t, U u);
}

3.1 Example for ToDoubleBiFunction :

  • Here, while defining lambda expression using ToDoubleBiFunction we haven’t specified any return-type like Double, still compiler doesn’t complain and executed well
  • And we have provided 2 input argument type as String, as we are converting into Double and then calculating average, so that it will return along with fractional part
package net.bench.resources.primitive.bifunction.example;

import java.util.function.ToDoubleBiFunction;

public class ToDoubleBiFunctionExample {

	public static void main(String[] args) {

		// lambda expression ToDoubleBiFunction FI

		ToDoubleBiFunction<String, String> tdbf = 
				(s1, s2) -> (Double.parseDouble(s1) + Double.parseDouble(s2)) / 2;

				// test above lambda with numbers
				System.out.println("1. Average of 5 and 7 : "
						+ tdbf.applyAsDouble("5","7"));

				System.out.println("2. Average of 25 and 76 : "
						+ tdbf.applyAsDouble("25","76"));

				System.out.println("3. Average of 963 and 755 : "
						+ tdbf.applyAsDouble("963","755"));

				System.out.println("4. Average of 1235 and 4312 : "
						+ tdbf.applyAsDouble("1235","4312"));

				System.out.println("5. Average of 54871 and 65148 : "
						+ tdbf.applyAsDouble("54871","65148"));

				System.out.println("6. Average of 102365 and 95684 : "
						+ tdbf.applyAsDouble("102365","956854"));
	}
}

Output:

1. Average of 5 and 7 : 6.0
2. Average of 25 and 76 : 50.5
3. Average of 963 and 755 : 859.0
4. Average of 1235 and 4312 : 2773.5
5. Average of 54871 and 65148 : 60009.5
6. Average of 102365 and 95684 : 529609.5

References:

Happy Coding !!
Happy Learning !!

Java 8 - Primitive Consumer Functional Interface
Java 8 - Primitive Function Functional Interface

Related posts:

  1. Java 8 – Functional Interface in Java
  2. Java 8 – BiPredicate Functional Interface
  3. Java 8 – BiFunction Functional Interface
  4. Java 8 – UnaryOperator and its primitive Functional Interface