UnaryOperator Interface

[BrianNeo00]

In Streams, the .Iterate() methods take in a UnaryOperator instead of a Function, but from what I can tell, it seems as though when you're defining the UnaryOperator, its exactly the same as if it was a Function? Is it actually the same as though i was defining a Function?

I know that UnaryOperator is a sub-interface of Function but i feel like I'm missing something, since if it was exactly the same as a Function, there wouldn't be a need for the UnaryOperator.

[OngMinXian]

if im not wrong, unaryoperator takes in a type T and will return a type T. So for example you have a stream of strings, then your iterate would apply a f that does str -> str over and over again. If it was something like a str -> int, that simply wouldnt work because afterwards you cant do str -> int again sicne you now know have an int

[liewyungjun]

unaryoperator is a implementation of function that takes in and outputs the same type. So you're restricting the types in the stream to be the same as that of the seed (by applying the unaryoperator on the seed).

[mohddanesh]

like what the others say, UnaryOperator has the same type for input and output. The difference between unaryoperator and function is that function can have input type T but output type R

[acekhoon]

unaryoperator is the one that takes the same input and output. Function is characterized by <? super T, ? extends R> but unaryoperator takes and output the same type, T.

[Penghao-99]

like what others have said, UnaryOperator requires input and output to be of the same type T. UnaryOperator extends Function<T,T>.
This is similar to BinaryOperator which extends BiFunction<T,T,T>.

[FredericChow00]

UnaryOperator is basically a Function that takes in and outputs the same type. It's a subclass of a Function

[cherylchan02]

It seems like it is the same but theres a very slight difference. If you look at the API UnaryOperator only has one one generic class which means that the input and the output of the function must be of the same type. This restriction is not present in function which can return a type that is different from the input type.

[yewey2]

I think having an example might help!

Let's say I want to add one to an integer, I can create either

Function<Integer, Integer> f = x -> x + 1

OR, use UnaryOperator

UnaryOperator<Integer> f = x -> x + 1

Usability wise it's easier to type Integer once (in UnaryOperator) than twice (in Function), but functionally they're the same.

Edit: Realised generics exists, so if the question asks you to accept inputs that are "related by some super-class or sub-class relationship", use Function instead