All 15 Functional Interfaces & Method References questions
More in Functional Interfaces & Method References
What is a functional interface, and what are the four core functional interfaces in java.util.function (Function, Predicate, Consumer, Supplier)? What are the four kinds of method references in Java (static, instance-bound, instance-unbound, and constructor), and how does the compiler determine which form applies? How do the default methods andThen() and compose() on Function work, and what's the difference between them for chaining transformations? How do the primitive-specialized functional interfaces (IntFunction, ToIntFunction, IntPredicate, IntUnaryOperator, etc.) avoid the performance cost of autoboxing, and when should you prefer them over the generic equivalents? How does the Predicate interface's default methods and(), or(), and negate() enable composing complex boolean conditions from simpler ones? What is the difference between a Consumer<T> and a BiConsumer<T,U>, and how would you use BiConsumer for operations needing two inputs but no return value, such as Map.forEach()? How would you convert a checked-exception-throwing method into a lambda usable with a standard functional interface (which doesn't declare any checked exceptions), given standard interfaces like Function don't permit checked exceptions in their abstract method signature? How does a lambda expression capture variables from its enclosing scope, and why must captured local variables be effectively final? How would you implement a custom functional interface with generic type parameters, and what considerations apply when designing one instead of reusing a built-in java.util.function interface? How would you implement memoization (caching function results) as a higher-order function wrapping an existing Function, and what thread-safety considerations apply for a memoized function used concurrently?
Advertisement
Java › Functional Interfaces & Method References

What is the difference between UnaryOperator<T> and Function<T,T>, and why does UnaryOperator exist as a separate, more specific interface?

Intermediate

Answer

UnaryOperator<T> extends Function<T,T> (a function whose input and output are the same type), existing as a more specific, semantically clearer name specifically for the common case where a transformation preserves its input's type (like a String-to-String transformation, or doubling a number) -- functionally it's interchangeable with Function<T,T> (inheriting the same apply() method plus andThen/compose), but using UnaryOperator communicates the same-type constraint more clearly to readers and provides a convenient static identity() factory method that Function alone doesn't offer with quite the same clarity.
UnaryOperator<String> toUpper = String::toUpperCase;
UnaryOperator<Integer> square = x -> x * x;

// Equivalent to Function<String, String> and Function<Integer, Integer>, but more semantically clear
UnaryOperator<String> identity = UnaryOperator.identity();  // returns its input unchanged
System.out.println(identity.apply("test"));  // "test"
Real-world example A List.replaceAll() call (which specifically requires a UnaryOperator<T> parameter, not just any Function<T,T>) is used to transform every element of a list in place, the API deliberately choosing the more semantically specific UnaryOperator type to communicate that the transformation must preserve the list's element type.

Common follow-ups: What's the equivalent 'BinaryOperator' interface, and what use case does it serve for combining two same-typed values?;Why does List.replaceAll() specifically require UnaryOperator rather than accepting a general Function?

Streams & Lambdas;Generics
All 15 Functional Interfaces & Method References questions