In this article, we will discuss different variation of pre-defined Function Functional Interface available for primitive data-types like int, long, double, etc. in Java 1.8 version
1. Primitive Function Functional Interface (input argument) :
- This is very similar to Function Functional Interface but it always accepts 1 input argument of type primitive-type like int, long and double, whereas Function allows to accepts any data-type and return result in any data-type
- Performance-wise primitive Function is much faster compared to Function<T, 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 Function Functional Interface for conversion introduced in Java 1.8 version as listed below,
- IntFunction
- LongFunction
- DoubleFunction
We will look into method signature along with example for each one of the above primitive Function Functional Interface
1.1 IntFunction Functional Interface
- This primitive IntFunction Functional Interface accepts 1-input argument of primitive int type and it is not required to declare while defining IntFunction (or lambda expression)
- But we have to provide return-type for IntFunction<R> and it can be any data-type depending upon our requirement
- Method signature: R apply(int value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface IntFunction<R> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
R apply(int value);
}
Example for IntFunction :
- Here, while defining lambda expression using IntFunction we haven’t specified any data-type like Integer for input argument, still compiler doesn’t complain and executed well
- And we have provided return-type as Integer, as square of number will be Integer only
- Caution: but if we pass any other data-type like String or double then compile-time error will be thrown stating “The method apply(int) in the type IntFunction is not applicable for the arguments (double)“
package net.bench.resources.primitive.function.example;
import java.util.function.IntFunction;
public class IntFunctionExample {
public static void main(String[] args) {
// lambda expression to find square of number using IntFunction FI
IntFunction<Integer> f = i -> i*i;
// computing Square of an Integer using IntFunction FI
System.out.println("1. The Square of number 5 is \t: "
+ f.apply(5));
System.out.println("2. The Square of number 9 is \t: "
+ f.apply(9));
System.out.println("3. The Square of number 27 is \t: "
+ f.apply(27));
System.out.println("4. The Square of number 33 is \t: "
+ f.apply(33));
System.out.println("5. The Square of number 43 is \t: "
+ f.apply(43));
}
}
Output:
1. The Square of number 5 is : 25
2. The Square of number 9 is : 81
3. The Square of number 27 is : 729
4. The Square of number 33 is : 1089
5. The Square of number 43 is : 1849
1.2 LongFunction Functional Interface
- This primitive LongFunction accepts 1-input argument of primitive long type and it is not required to declare while defining LongFunction (or lambda expression)
- But we have to provide return-type for LongFunction<R> and it can be any data-type depending upon our requirement
- Method signature: R apply(long value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface LongFunction<R> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
R apply(long value);
}
Example for LongFunction :
- Here, while defining lambda expression using LongFunction we haven’t specified any data-type like Long for input argument, still compiler doesn’t complain and executed well
- And we have provided return-type as Boolean, as lambda expression evaluates whether provided long value is positive or negative
- Caution: but if we pass any other data-type like String or double then compile-time error will be thrown stating “The method apply(long) in the type LongFunction is not applicable for the arguments (double)“
package net.bench.resources.primitive.function.example;
import java.util.function.LongFunction;
public class LongFunctionExample {
public static void main(String[] args) {
// lambda expression for LongFunction to check number is positive or negative
LongFunction<Boolean> lf = longNum -> longNum >= 0;
// testing for different numbers using above lambda expression
System.out.println("1. Whether 10 is postive number : "
+ lf.apply(10));
System.out.println("2. Whether -7 is postive number : "
+ lf.apply(-7));
System.out.println("3. Whether 19 is postive number : "
+ lf.apply(19));
System.out.println("4. Whether -32 is postive number : "
+ lf.apply(-32));
System.out.println("5. Whether 41 is postive number : "
+ lf.apply(41));
}
}
Output:
1. Whether 10 is postive number : true
2. Whether -7 is postive number : false
3. Whether 19 is postive number : true
4. Whether -32 is postive number : false
5. Whether 41 is postive number : true
1.3 DoubleFunction Functional Interface
- This primitive DoubleFunction accepts 1-input argument of primitive double type and it is not required to declare while defining DoubleFunction (or lambda expression)
- But we have to provide return-type for DoubleFunction<R> and it can be any data-type depending upon our requirement
- Method signature: R apply(double value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface DoubleFunction<R> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
R apply(double value);
}
Example for DoubleFunction :
- Here, while defining lambda expression using DoubleFunction we haven’t specified any data-type like Double for input argument, still compiler doesn’t complain and executed well
- And we have provided return-type as String, as lambda expression return String value
- Caution: but if we pass any other data-type like String then compile-time error will be thrown stating “The method apply(double) in the type DoubleFunction is not applicable for the arguments (String)“
package net.bench.resources.primitive.function.example;
import java.util.function.DoubleFunction;
public class DoubleFunctionExample {
public static void main(String[] args) {
// lambda expression for DoubleFunction to check CGPA is greater than 6.7
DoubleFunction<String> df = d -> "you have cleared IIT-JEE with " + d + " CGPA";
// testing for different numbers using above lambda expression
System.out.println("Suresh, " + df.apply(9.2));
System.out.println("Naresh, " + df.apply(6.7));
System.out.println("Rajesh, " + df.apply(7.9));
System.out.println("Ramesh, " + df.apply(8.9));
System.out.println("Lokesh, " + df.apply(7.3));
}
}
Output:
Suresh, you have cleared IIT-JEE with 9.2 CGPA
Naresh, you have cleared IIT-JEE with 6.7 CGPA
Rajesh, you have cleared IIT-JEE with 7.9 CGPA
Ramesh, you have cleared IIT-JEE with 8.9 CGPA
Lokesh, you have cleared IIT-JEE with 7.3 CGPA
2. Primitive Function Functional Interface (return-type) :
- This is very similar to Function Functional Interface where it accepts 1 input argument of any data-type but return-type must be primitive-type like int, long and double, etc, whereas Function allows to accepts any data-type and return result in any data-type
- Performance-wise primitive Function is much faster compared to Function<T, 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 Function Functional Interface for conversion introduced in Java 1.8 version as listed below,
- ToIntFunction
- ToLongFunction
- ToDoubleFunction
We will look into method signature along with example for each one of the above primitive Function Functional Interface
2.1 ToIntFunction Functional Interface
- This primitive ToIntFunction Functional Interface always returns value in primitive-type int only and it is not required to declare while defining ToIntFunction (or lambda expression)
- But we have to provide input argument for ToIntFunction<T> and it can be any data-type depending upon our requirement
- Method signature: int applyAsInt(T value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface ToIntFunction<T> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
int applyAsInt(T value);
}
Example for ToIntFunction :
- Here, while defining lambda expression using ToIntFunction we haven’t specified any return-type like Integer, still compiler doesn’t complain and executed well
- And we have provided input argument type as Integer, as we are calculating square of number
package net.bench.resources.primitive.function.example;
import java.util.function.ToIntFunction;
public class ToIntFunctionExample {
public static void main(String[] args) {
// lambda expression to find square of number using ToIntFunction FI
ToIntFunction<Integer> f = i -> i*i;
// computing Square of an Integer using Function FI
System.out.println("1. The Square of number 5 is \t: "
+ f.applyAsInt(5));
System.out.println("2. The Square of number 9 is \t: "
+ f.applyAsInt(9));
System.out.println("3. The Square of number 27 is \t: "
+ f.applyAsInt(27));
System.out.println("4. The Square of number 33 is \t: "
+ f.applyAsInt(33));
System.out.println("5. The Square of number 43 is \t: "
+ f.applyAsInt(43));
}
}
Output:
1. The Square of number 5 is : 25
2. The Square of number 9 is : 81
3. The Square of number 27 is : 729
4. The Square of number 33 is : 1089
5. The Square of number 43 is : 1849
2.2 ToLongFunction Functional Interface
- This primitive ToLongFunction Functional Interface always returns value in primitive-type long only and it is not required to declare while defining ToLongFunction (or lambda expression)
- But we have to provide input argument for ToLongFunction<T> and it can be any data-type depending upon our requirement
- Method signature: long applyAsLong(T value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface ToLongFunction<T> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
long applyAsLong(T value);
}
Example for ToLongFunction :
- Here, while defining lambda expression using ToLongFunction we haven’t specified any return-type like Long, still compiler doesn’t complain and executed well
- And we have provided input argument type as Integer, as we are multiplying this number with 1024
package net.bench.resources.primitive.function.example;
import java.util.function.ToLongFunction;
public class ToLongFunctionExample {
public static void main(String[] args) {
// lambda expression to multiply number with 1024 using ToLongFunction FI
ToLongFunction<Integer> f = i -> i*1024;
// multiply below number using above ToLongFunction FI
System.out.println("1. 5 * 1024 = \t" + f.applyAsLong(5));
System.out.println("2. 9 * 1024 = \t" + f.applyAsLong(9));
System.out.println("3. 27 * 1024 = \t" + f.applyAsLong(27));
System.out.println("4. 33 * 1024 = \t" + f.applyAsLong(33));
System.out.println("5. 43 * 1024 = \t" + f.applyAsLong(43));
}
}
Output:
1. 5 * 1024 = 5120
2. 9 * 1024 = 9216
3. 27 * 1024 = 27648
4. 33 * 1024 = 33792
5. 43 * 1024 = 44032
2.3 ToDoubleFunction Functional Interface
- This primitive ToDoubleFunction Functional Interface always returns value in primitive-type double only and it is not required to declare while defining ToDoubleFunction (or lambda expression)
- But we have to provide input argument for ToDoubleFunction<T> and it can be any data-type depending upon our requirement
- Method signature: double applyAsDouble(T value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface ToDoubleFunction<T> {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
double applyAsDouble(T value);
}
Example for ToDoubleFunction :
- Here, while defining lambda expression using ToDoubleFunction we haven’t specified any return-type like Double, still compiler doesn’t complain and executed well
- And we have provided input argument type as Integer, as we are subtracting this number with 0.5 which results in double value to be returned
package net.bench.resources.primitive.function.example;
import java.util.function.ToDoubleFunction;
public class ToDoubleFunctionExample {
public static void main(String[] args) {
// lambda expression for ToDoubleFunction FI for subtraction to get double value
ToDoubleFunction<Integer> df = i -> i - 0.5;
// testing for different numbers using above lambda expression
System.out.println("1. After discount, for 5 is \t= "
+ df.applyAsDouble(5));
System.out.println("2. After discount, for 7 is \t= "
+ df.applyAsDouble(7));
System.out.println("3. After discount, for 32 is \t= "
+ df.applyAsDouble(32));
System.out.println("4. After discount, for 28 is \t= "
+ df.applyAsDouble(28));
System.out.println("5. After discount, for 25 is \t= "
+ df.applyAsDouble(55));
}
}
Output:
1. After discount, for 5 is = 4.5
2. After discount, for 7 is = 6.5
3. After discount, for 32 is = 31.5
4. After discount, for 28 is = 27.5
5. After discount, for 25 is = 54.5
3. Primitive Function Functional Interface (conversion) :
- This is very similar to Function Functional Interface but here both input argument type as well as return-type is defined as primitive-types like int, long and double, etc, whereas Function allows to accepts any data-type and return result in any data-type
- Performance-wise primitive Function is much faster compared to Function<T, 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 Function Functional Interface for conversion introduced in Java 1.8 version as listed below,
- IntToLongFunction
- IntToDoubleFunction
- LongToIntFunction
- LongToDoubleFunction
- DoubleToIntFunction
- DoubleToLongFunction
We will look into method signature along with example for each one of the above primitive Function FI
3.1 IntToLongFunction Functional Interface
- This primitive IntToLongFunction Functional Interface accepts 1-input argument of primitive–type int and returns value in primitive-type long only and it is not required to declare while defining IntToLongFunction (or lambda expression)
- Method signature: long applyAsLong(int value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface IntToLongFunction {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
long applyAsLong(int value);
}
Example for IntToLongFunction :
- Here, while defining lambda expression using IntToLongFunction we are not defining type for both input argument and return-type
- As this are fixed now, input argument type should be primitive-type int only and return-type should be primitive-type long only
- Caution: any other type results in compile-time error
package net.bench.resources.primitive.function.example;
import java.util.function.IntToLongFunction;
public class IntToLongFunctionExample {
public static void main(String[] args) {
// lambda expression for IntToLongFunction FI
IntToLongFunction ilf = i -> i * 2048;
// testing with different int number
// multiply below number using above ToLongFunction FI
System.out.println("1. 5 * 2048 = \t" + ilf.applyAsLong(5));
System.out.println("2. 9 * 2048 = \t" + ilf.applyAsLong(9));
System.out.println("3. 27 * 2048 = \t" + ilf.applyAsLong(27));
System.out.println("4. 33 * 2048 = \t" + ilf.applyAsLong(33));
System.out.println("5. 43 * 2048 = \t" + ilf.applyAsLong(43));
}
}
Output:
1. 5 * 2048 = 10240
2. 9 * 2048 = 18432
3. 27 * 2048 = 55296
4. 33 * 2048 = 67584
5. 43 * 2048 = 88064
3.2 IntToDoubleFunction Functional Interface
- This primitive IntToDoubleFunction Functional Interface accepts 1-input argument of primitive-type int and returns value in primitive-type double only and it is not required to declare while defining IntToDoubleFunction (or lambda expression)
- Method signature: double applyAsDouble(int value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface IntToDoubleFunction {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
double applyAsDouble(int value);
}
Example for IntToDoubleFunction :
- Here, while defining lambda expression using IntToDoubleFunction we are not defining type for both input argument and return-type
- As this are fixed now, input argument type should be primitive-type int only and return-type should be primitive-type double only
- Caution: any other type results in compile-time error
package net.bench.resources.primitive.function.example;
import java.util.function.IntToDoubleFunction;
public class IntToDoubleFunctionExample {
public static void main(String[] args) {
// lambda expression for IntToDoubleFunction FI
IntToDoubleFunction idf = i -> i * 0.05;
// testing with different int number
// multiply below number using above ToDoubleFunction FI
System.out.println("1. 7 * 0.05 = \t" + idf.applyAsDouble(7));
System.out.println("2. 19 * 0.05 = \t" + idf.applyAsDouble(19));
System.out.println("3. 23 * 0.05 = \t" + idf.applyAsDouble(23));
System.out.println("4. 33 * 0.05 = \t" + idf.applyAsDouble(33));
System.out.println("5. 41 * 0.05 = \t" + idf.applyAsDouble(41));
}
}
Output:
1. 7 * 0.05 = 0.35000000000000003
2. 19 * 0.05 = 0.9500000000000001
3. 23 * 0.05 = 1.1500000000000001
4. 33 * 0.05 = 1.6500000000000001
5. 41 * 0.05 = 2.0500000000000003
3.3 LongToIntFunction Functional Interface
- This primitive LongToIntFunction Functional Interface accepts 1-input argument of primitive-type long and returns value in primitive-type int only and it is not required to declare while defining LongToIntFunction (or lambda expression)
- Method signature: int applyAsInt(long value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface LongToIntFunction {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
int applyAsInt(long value);
}
Example for LongToIntFunction :
- Here, while defining lambda expression using LongToIntFunction we are not defining type for both input argument and return-type
- As this are fixed now, input argument type should be primitive-type long only and return-type should be primitive-type int only
- Caution: any other type results in compile-time error
package net.bench.resources.primitive.function.example;
import java.util.function.LongToIntFunction;
public class LongToIntFunctionExample {
public static void main(String[] args) {
// lambda expression for IntToLongFunction FI
LongToIntFunction lif = l -> (int)(l/1024);
// divide below number by 1024 using above LongToIntFunction FI
System.out.println("1. 2048 / 1024 = " + lif.applyAsInt(2048));
System.out.println("2. 7168 / 1024 = " + lif.applyAsInt(7168));
System.out.println("3. 19456 / 1024 = " + lif.applyAsInt(19456));
System.out.println("4. 31744 / 1024 = " + lif.applyAsInt(31744));
System.out.println("5. 65536 / 1024 = " + lif.applyAsInt(65536));
}
}
Output:
1. 2048 / 1024 = 2
2. 7168 / 1024 = 7
3. 19456 / 1024 = 19
4. 31744 / 1024 = 31
5. 65536 / 1024 = 64
3.4 LongToDoubleFunction Functional Interface
- This primitive LongToDoubleFunction Functional Interface accepts 1-input argument of primitive-type long and returns value in primitive-type double only and it is not required to declare while defining LongToDoubleFunction (or lambda expression)
- Method signature: double applyAsDouble(long value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface LongToDoubleFunction {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
double applyAsDouble(long value);
}
Example for LongToDoubleFunction :
- Here, while defining lambda expression using LongToDoubleFunction we are not defining type for both input argument and return-type
- As this are fixed now, input argument type should be primitive-type long only and return-type should be primitive-type int only
- Caution: any other type results in compile-time error
package net.bench.resources.primitive.function.example;
import java.util.function.LongToDoubleFunction;
public class LongToDoubleExample {
public static void main(String[] args) {
// lambda expression for LongToDoubleFunction FI
LongToDoubleFunction ltd = l -> l * 0.123;
// test with few long values
System.out.println("1. 123456 * 0.123 = " + ltd.applyAsDouble(123456));
System.out.println("2. 654321 * 0.123 = " + ltd.applyAsDouble(654321));
System.out.println("3. 963258 * 0.123 = " + ltd.applyAsDouble(963258));
System.out.println("4. 741236 * 0.123 = " + ltd.applyAsDouble(741236));
System.out.println("5. 842657 * 0.123 = " + ltd.applyAsDouble(842657));
}
}
Output:
1. 123456 * 0.123 = 15185.088
2. 654321 * 0.123 = 80481.483
3. 963258 * 0.123 = 118480.734
4. 741236 * 0.123 = 91172.028
5. 842657 * 0.123 = 103646.811
3.5 DoubleToIntFunction Functional Interface
- This primitive DoubleToIntFunction Functional Interface accepts 1-input argument of primitive-type double and returns value in primitive-type int only and it is not required to declare while defining DoubleToIntFunction (or lambda expression)
- Method signature: int applyAsInt(double value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface DoubleToIntFunction {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
int applyAsInt(double value);
}
Example for DoubleToIntFunction :
- Here, while defining lambda expression using DoubleToIntFunction we are not defining type for both input argument and return-type
- As this are fixed now, input argument type should be primitive-type double only and return-type should be primitive-type int only
- Caution: any other type results in compile-time error
package net.bench.resources.primitive.function.example;
import java.util.function.DoubleToIntFunction;
public class DoubleToIntFunctionExample {
public static void main(String[] args) {
// lambda expression for DoubleToIntFunction FI
DoubleToIntFunction dti = d -> (int)d;
// test above lambda with few number
System.out.println("1. After removing fractional part from 9.3 \t= "
+ dti.applyAsInt(9.3));
System.out.println("2. After removing fractional part from 99.623 \t= "
+ dti.applyAsInt(99.623));
System.out.println("3. After removing fractional part from 63.124 \t= "
+ dti.applyAsInt(63.124));
System.out.println("4. After removing fractional part from -35.25 \t= "
+ dti.applyAsInt(-35.25));
System.out.println("5. After removing fractional part from 0.23658 \t= "
+ dti.applyAsInt(0.23658));
}
}
Output:
1. After removing fractional part from 9.3 = 9
2. After removing fractional part from 99.623 = 99
3. After removing fractional part from 63.124 = 63
4. After removing fractional part from -35.25 = -35
5. After removing fractional part from 0.23658 = 0
3.6 DoubleToLongFunction Functional Interface
- This primitive DoubleToLongFunction Functional Interface accepts 1-input argument of primitive-type double and returns value in primitive-type long only and it is not required to declare while defining DoubleToLongFunction (or lambda expression)
- Method signature: long applyAsLong(double value);
package java.util.function;
import java.util.function.Function;
@FunctionalInterface
public interface DoubleToLongFunction {
/**
* Applies this function to the given argument.
*
* @param value the function argument
* @return the function result
*/
long applyAsLong(double value);
}
Example for DoubleToLongFunction :
- Here, while defining lambda expression using DoubleToLongFunction we are not defining type for both input argument and return-type
- As this are fixed now, input argument type should be primitive-type double only and return-type should be primitive-type long only
- Caution: any other type results in compile-time error
package net.bench.resources.primitive.function.example;
import java.util.function.DoubleToLongFunction;
public class DoubleToLongFunctionExample {
public static void main(String[] args) {
// lambda expression for DoubleToLongFunction FI
DoubleToLongFunction dti = d -> (long)d;
// test above lambda with few number
System.out.println("1. After removing fractional part from 3.14 \t= "
+ dti.applyAsLong(3.14));
System.out.println("2. After removing fractional part from 22.7 \t= "
+ dti.applyAsLong(22.7));
System.out.println("3. After removing fractional part from 36.421 \t= "
+ dti.applyAsLong(36.421));
System.out.println("4. After removing fractional part from -27.45 \t= "
+ dti.applyAsLong(-27.45));
System.out.println("5. After removing fractional part from 0.12345 \t= "
+ dti.applyAsLong(0.12345));
}
}
Output:
1. After removing fractional part from 3.14 = 3
2. After removing fractional part from 22.7 = 22
3. After removing fractional part from 36.421 = 36
4. After removing fractional part from -27.45 = -27
5. After removing fractional part from 0.12345 = 0
References:
- https://docs.oracle.com/javase/8/docs/api/java/util/function/IntFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/LongFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/DoubleFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/ToIntFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/ToLongBiFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/ToDoubleFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/IntToLongFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/IntToDoubleFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/LongToIntFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/LongToDoubleFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/DoubleToIntFunction.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/DoubleToLongFunction.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
Happy Coding !!
Happy Learning !!
