How do I use the IntUnaryOperator functional interface in Java?

The IntUnaryOperator is a functional interface in Java that resides in the java.util.function package. It represents a function that accepts a single int-valued argument and produces an int-valued result. It is often used when working with Lambda expressions or method references where we need to process integers.

Here’s a detailed explanation of how to use IntUnaryOperator with examples:

1. Signature of `IntUnaryOperator`

The IntUnaryOperator interface has a single abstract method:

int applyAsInt(int operand);

This method takes an int as input and returns another int as output.

2. Syntax and Lambda Expression

We can use IntUnaryOperator by providing an implementation of the applyAsInt method, typically through a lambda expression or method reference.

// Doubles the input value
IntUnaryOperator operator = (int x) -> x * 2;
// Result is 10
int result = operator.applyAsInt(5);

3. Static Methods Available

The interface also provides some default or additional static methods to combine or chain operations:

a. `compose` method

The compose method allows we to first apply another IntUnaryOperator and then apply the current operator.

IntUnaryOperator operator1 = x -> x + 3; // Adds 3
IntUnaryOperator operator2 = x -> x * 2; // Doubles the value

// First apply 'operator1', then 'operator2'
IntUnaryOperator combined = operator2.compose(operator1);

// Result is (5 + 3) * 2 = 16
int result = combined.applyAsInt(5);

b. `andThen` method

This method allows we to first apply the current operator and then apply another operator.

IntUnaryOperator operator1 = x -> x + 3; // Adds 3
IntUnaryOperator operator2 = x -> x * 2; // Doubles the value

// First apply 'operator1', then 'operator2'
IntUnaryOperator combined = operator1.andThen(operator2);

// Result is (5 + 3) * 2 = 16
int result = combined.applyAsInt(5);

c. `identity` method

The identity method returns an IntUnaryOperator that always returns its input value unchanged.

IntUnaryOperator identityOperator = IntUnaryOperator.identity();
// Result is 10
int result = identityOperator.applyAsInt(10);

4. Use Cases

Mapping values in an array or collection:

package org.kodejava.util.function;

import java.util.Arrays;
import java.util.function.IntUnaryOperator;

public class MappingValueExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        IntUnaryOperator doubleOperator = x -> x * 2;

        int[] doubledNumbers = Arrays.stream(numbers)
                .map(doubleOperator)
                .toArray();

        // Output: [2, 4, 6, 8, 10]
        System.out.println(Arrays.toString(doubledNumbers));
    }
}

Chaining multiple operations:

package org.kodejava.util.function;

import java.util.function.IntUnaryOperator;

public class ChainOperationExample {
    public static void main(String[] args) {
        int number = 5;

        IntUnaryOperator addFive = x -> x + 5;
        IntUnaryOperator square = x -> x * x;

        IntUnaryOperator combinedOperator = addFive.andThen(square);
        int result = combinedOperator.applyAsInt(number); // (5 + 5)² = 100

        // Output: Result: 100
        System.out.println("Result: " + result);
    }
}

5. Key Benefits

Simplifies working with single-argument integer operations.
Performs operations without boxing/unboxing overhead, as it uses primitive int instead of Integer.
Easily composable with methods like compose and andThen.

This functional interface is useful in various scenarios, especially when we want to perform operations or transformations on primitive int values in a concise manner.

Author
Recent Posts

Wayan

Founder at Kode Java

A Java programmer who lives on the island of Bali, Indonesia. Programming in Spring Framework, Hibernate / JPA, MySQL. To support me working on this project, buy me a cup of coffee, every little bit helps. Thank you.

1. Signature of IntUnaryOperator

2. Syntax and Lambda Expression

3. Static Methods Available

a. compose method

b. andThen method

c. identity method