- A+

I was learning to write some lambda representation as FunctionalInterface. So, to add two integers I used:

`BiFunction<Integer, Integer, Integer> biFunction = (a, b) -> a + b; System.out.println(biFunction.apply(10, 60)); `

Gives me the output **70**. But if I write it as this

`BinaryOperator<Integer, Integer, Integer> binaryOperator = (a, b) -> a + b; `

I get an error saying

Wrong number of type arguments: 3; required: 1

Isn't `BinaryOperator`

a child of `BinaryFunction`

? How do I improve it?

`BinaryOperator`

Since `BinaryOperator`

works on a *single type of operands and result*. i.e. `BinaryOperator<T>`

.

Isn't BinaryOperator a child of BinaryFunction?

Yes. `BinaryOperator`

does `extends BiFunction`

. But do note the documentation states(formatting mine):

This is a specialization of

`BiFunction`

for the case where theoperands and the result are all of the.same type

The complete representation is as:

`BinaryOperator<T> extends BiFunction<T,T,T> `

hence your code shall work with

`BinaryOperator<Integer> binaryOperator = (a, b) -> a + b; System.out.println(binaryOperator.apply(10, 60)); `

### IntBinaryOperator

If you're supposed to be dealing with two primitive integers as currently in your example (*add two integers I used*), you can make use of the `IntBinaryOperator`

FunctionalInterface as

`IntBinaryOperator intBinaryOperator = (a, b) -> a + b; System.out.println(intBinaryOperator.applyAsInt(10, 60)); `

Represents an operation upon two

`int`

-valued operands and producing an int-valued result. This is theprimitive type specializationof`BinaryOperator`

for`int`

.

I am using Integer, can I still use IntBinaryOperator

Yes, you can still use it ** but** notice the representation of the

`IntBinaryOperator`

`Integer first = 10; Integer second = 60; IntBinaryOperator intBinaryOperator = new IntBinaryOperator() { @Override public int applyAsInt(int a, int b) { return Integer.sum(a, b); } }; Integer result = intBinaryOperator.applyAsInt(first, second); `

would incur you an overhead of *unboxing* `first`

and `second`

to primitives and then *autoboxing* the sum as an output to `result`

of type `Integer`

.

** Note**: Be careful of using

*null-safe values*for the

`Integer`

though or else you would probably end up with a `NullPointerException`

.