In this article, we will discuss UnaryOperator Functional Interface which is sub-interface of Function Functional Interface where,
- Function Functional Interface – accepts 1 input argument and a return-type of any data-type
- UnaryOperator Functional Interface – accepts 1-input argument and a return-type of same data-type
In a way, it is very similar to Function<T,R> Functional Interface except that both input-argument and return-type are same
1. UnaryOperator Functional Interface :
- UnaryOperator accepts 1-input argument whose data-type is same as that of return-type
- This is very much similar to Function Functional Interface
- UnaryOperator<T> extends Function<T, T> and inherits apply(); method from Function Functional Interface
- In Function<T, R> Functional Interface, we specify data-type for both input-argument and return-type separately with comma in between
- Whereas in UnaryOperator<T> we specify only one type because this will be same for both input argument and return-type
- Method signature: T apply(T value); inherited from Function Functional Interface
package java.util.function; @FunctionalInterface public interface UnaryOperator<T> extends Function<T, T> { // other default and static methods }
1.1 Example for UnaryOperator Functional Interface :
- We will look into 2 examples
- 1st example – data-type is String where it accepts String and returns sub-string for 1st 3 characters
- 2nd example – data-type is Integer where it accepts number and returns number multiplied by 19
package net.bench.resources.primitive.unaryoperator.example; import java.util.function.UnaryOperator; public class UnaryOperatorExample { public static void main(String[] args) { // 1. lambda expression to get 1st three character using UnaryOperator FI UnaryOperator<String> uos = s -> s.substring(0, 3); System.out.println("1. Sub-string = " + uos.apply("BenchResources.Net")); // 2. lambda expression for multiplication by 19 using UnaryOperator FI UnaryOperator<Integer> uoi = i -> i*19; System.out.println("2. 17 * 19 = " + uoi.apply(17)); } }
Output:
1. Sub-string = Ben 2. 17 * 19 = 323
2. Primitive UnaryOperator Functional Interface :
- This is very much similar to what we discussed above in UnaryOperator Functional Interface but it accepts 1 input argument & return-type is always of primitive-type like int, long, double, etc. whereas UnaryOperator Functional Interface allows to accept any data-type
- Performance-wise primitive UnaryOperator Functional Interface is much faster compared to UnaryOperator<T>
- 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 UnaryOperator Functional Interface for conversion introduced in Java 1.8 version as listed below
- IntUnaryOperator
- LongUnaryOperator
- DoubleUnaryOperator
We will look into method signature along with example for each one of the above mentioned Primitive UnaryOperator Functional Interface
2.1 IntUnaryOperator Functional Interface :
- This primitive IntUnaryOperator Functional Interface accepts 1-input argument and return-type of primitive–type int and it is not required to declare while defining IntUnaryOperator (or lambda expression)
- Method signature: int applyAsInt(int operand);
package java.util.function; import java.util.Objects; @FunctionalInterface public interface IntUnaryOperator { /** * Applies this operator to the given operand. * * @param operand the operand * @return the operator result */ int applyAsInt(int operand); // other default and static methods }
2.1.1 Example for IntUnaryOperator Functional Interface :
- Here, while defining lambda expression using IntUnaryOperator we haven’t specified any data-type like Integer for input argument and return-type, still compiler doesn’t complain and executed well
- By default it will consider primitive-type int for both input argument and return-type
package net.bench.resources.primitive.unaryoperator.example; import java.util.function.IntUnaryOperator; public class IntUnaryOperatorExample { public static void main(String[] args) { // lambda expression to get square value using IntUnaryOperator FI IntUnaryOperator iuo = i -> i*i; // testing/calculating square for above lambda expression with below numbers System.out.println("1. Square of 2 is = " + iuo.applyAsInt(2)); System.out.println("2. Square of 19 is = " + iuo.applyAsInt(19)); System.out.println("3. Square of 37 is = " + iuo.applyAsInt(37)); System.out.println("4. Square of 15 is = " + iuo.applyAsInt(15)); System.out.println("5. Square of 20 is = " + iuo.applyAsInt(20)); } }
Output:
1. Square of 2 is = 4 2. Square of 19 is = 361 3. Square of 37 is = 1369 4. Square of 15 is = 225 5. Square of 20 is = 400
2.2 LongUnaryOperator Functional Interface :
- This primitive LongUnaryOperator Functional Interface accepts 1-input argument and return-type of primitive–type long and it is not required to declare while defining LongUnaryOperator (or lambda expression)
- Method signature: long applyAsLong(long operand);
package java.util.function; import java.util.Objects; @FunctionalInterface public interface LongUnaryOperator { /** * Applies this operator to the given operand. * * @param operand the operand * @return the operator result */ long applyAsLong(long operand); // other default and static methods }
2.2.1 Example for LongUnaryOperator Functional Interface :
- Here, while defining lambda expression using LongUnaryOperator we haven’t specified any data-type like Long for input argument and return-type, still compiler doesn’t complain and executed well
- By default it will consider primitive-type long for both input argument and return-type
package net.bench.resources.primitive.unaryoperator.example; import java.util.function.LongUnaryOperator; public class LongUnaryOperatorExample { public static void main(String[] args) { // lambda expression to get cube value using LongUnaryOperator FI LongUnaryOperator luo = l -> l*l*l; // testing/calculating cube for above lambda expression with below numbers System.out.println("1. Cube of 2 is = " + luo.applyAsLong(2l)); System.out.println("2. Cube of 19 is = " + luo.applyAsLong(19l)); System.out.println("3. Cube of 37 is = " + luo.applyAsLong(37l)); System.out.println("4. Cube of 15 is = " + luo.applyAsLong(15l)); System.out.println("5. Cube of 20 is = " + luo.applyAsLong(20l)); } }
Output:
1. Cube of 2 is = 8 2. Cube of 19 is = 6859 3. Cube of 37 is = 50653 4. Cube of 15 is = 3375 5. Cube of 20 is = 8000
2.3 DoubleUnaryOperator Functional Interface :
- This primitive DoubleUnaryOperator Functional Interface accepts 1-input argument and return-type of primitive–type double and it is not required to declare while defining DoubleUnaryOperator (or lambda expression)
- Method signature: double applyAsDouble(double operand);
package java.util.function; import java.util.Objects; @FunctionalInterface public interface DoubleUnaryOperator { /** * Applies this operator to the given operand. * * @param operand the operand * @return the operator result */ double applyAsDouble(double operand); // other default and static methods }
2.3.1 Example for DoubleUnaryOperator Functional Interface :
- Here, while defining lambda expression using DoubleUnaryOperator we haven’t specified any data-type like Double for input argument and return-type, still compiler doesn’t complain and executed well
- By default it will consider primitive-type double for both input argument and return-type
package net.bench.resources.primitive.unaryoperator.example; import java.util.function.DoubleUnaryOperator; public class DoubleUnaryOperatorExample { public static void main(String[] args) { // lambda expression to get square value using DoubleUnaryOperator FI DoubleUnaryOperator duo = d -> d*d; // testing/calculating square for above lambda expression with below numbers System.out.println("1. Square of 2.5 is = " + duo.applyAsDouble(2.5)); System.out.println("2. Square of 7.1 is = " + duo.applyAsDouble(7.1)); System.out.println("3. Square of 3.7 is = " + duo.applyAsDouble(3.7)); System.out.println("4. Square of 1.2 is = " + duo.applyAsDouble(1.2)); System.out.println("5. Square of 9.3 is = " + duo.applyAsDouble(9.3)); } }
Output:
1. Square of 2.5 is = 6.25 2. Square of 7.1 is = 50.41 3. Square of 3.7 is = 13.690000000000001 4. Square of 1.2 is = 1.44 5. Square of 9.3 is = 86.49000000000001
References:
- https://docs.oracle.com/javase/8/docs/api/java/util/function/UnaryOperator.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/IntUnaryOperator.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/LongUnaryOperator.html
- https://docs.oracle.com/javase/8/docs/api/java/util/function/DoubleUnaryOperator.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 !!