How do I use the BinaryOperator functional interface in Java?

The BinaryOperator interface in Java is a functional interface that extends the BiFunction interface. It takes two arguments of the same type and produces a result of the same type. It is typically used for functional-style operations where two operands of the same type need to be combined into one result.

Key Details about `BinaryOperator`:

Located in the java.util.function package.
It is a generic interface (BinaryOperator<T>), where T is the type of input arguments and the return type.
It comes with useful static methods like minBy() and maxBy() to create comparators.

Functional Method

The BinaryOperator interface declares the following functional method:

T apply(T t1, T t2);

This method applies the operation to the given arguments and returns the result.

Example Usage of the `BinaryOperator` Interface

Sum of Two Integers:

We can use BinaryOperator to perform simple addition:

package org.kodejava.util.function;

import java.util.function.BinaryOperator;

public class SumOfTwoIntegers {
    public static void main(String[] args) {
        BinaryOperator<Integer> add = (a, b) -> a + b;

        // Output: 30
        System.out.println("Sum: " + add.apply(10, 20));
    }
}

Find Maximum or Minimum Using Comparators

Using BinaryOperator.maxBy() and BinaryOperator.minBy(), we can determine the maximum or minimum value based on a given comparator:

package org.kodejava.util.function;

import java.util.function.BinaryOperator;
import java.util.Comparator;

public class MaxMinComparator {
    public static void main(String[] args) {
        BinaryOperator<Integer> maxOperator =
                BinaryOperator.maxBy(Comparator.naturalOrder());
        BinaryOperator<Integer> minOperator =
                BinaryOperator.minBy(Comparator.naturalOrder());

        // Output: 20
        System.out.println("Max: " + maxOperator.apply(10, 20));
        // Output: 10
        System.out.println("Min: " + minOperator.apply(10, 20));
    }
}

String Concatenation:

BinaryOperator can also work with strings or other types:

package org.kodejava.util.function;

import java.util.function.BinaryOperator;

public class ConcatenateString {
    public static void main(String[] args) {
        BinaryOperator<String> concat =
                (str1, str2) -> str1 + str2;

        // Output: Hello, World!
        System.out.println("Concatenated String: " +
                           concat.apply("Hello, ", "World!"));
    }
}

Common Use Cases:

Arithmetic operations (e.g., add, subtract, multiply, divide).
Aggregation functions (e.g., finding the maximum, minimum, or average of elements).
Combining elements in functional streams.
Handling data transformations using custom logic.

Integrating with Streams:

BinaryOperator is often used in reduce() operations of a Stream:

package org.kodejava.util.function;

import java.util.stream.Stream;
import java.util.function.BinaryOperator;

public class BinaryOperatorInStream {
    public static void main(String[] args) {
        BinaryOperator<Integer> add = Integer::sum;

        // Reduce the stream with addition
        Integer sum = Stream.of(1, 2, 3, 4, 5)
                .reduce(0, add);

        // Output: 15
        System.out.println("Total: " + sum);
    }
}

Author
Recent Posts

Wayan

Founder at Kode Java

Hi, I'm a passionate programmer based on the beautiful island of Bali. I specialize in Java, with hands-on experience in Spring, Hibernate/JPA, and MySQL. I'm currently working on a project I care deeply about, and your support—big or small—helps fuel my work (and my coffee ☕️).

If you like what I’m building, consider buying me a cup of coffee. Thanks a lot!

Key Details about BinaryOperator: