# UnaryOperator Interface in Java

The **UnaryOperator Interface<T>** is a part of the **java.util.function** package which has been introduced since Java 8, to implement functional programming in Java. It represents a function which takes in one argument and operates on it. However what distinguishes it from a normal Function is that both its argument and return type are the same.

Hence this functional interface which takes in one generic namely:-

Attention reader! Don’t stop learning now. Get hold of all the important **Java Foundation** and Collections concepts with the **Fundamentals of Java and Java Collections Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

**T**: denotes the type of the input argument to the operation

Hence the UnaryOperator<T> overloads the Function<T, T> type. So it inherits the following methods from the Function Interface:

- T apply(T t)
- default <V> Function<T, V> andThen(Function<? super R, ? extends V> after)
- default <V> Function<V, R> compose(Function<? super V, ? extends T> before)

The lambda expression assigned to an object of UnaryOperator type is used to define its **accept()** which eventually applies the given operation on its argument.

### Functions in UnaryOperator Interface

The UnaryOperator interface consists of the following functions:

### 1. identity()

This method returns a UnaryOperator which takes in one value and returns it. The returned UnaryOperator does not perform any operation on its only value.

**Syntax:**

static UnaryOperator identity()

**Parameters:** This method does not take in any parameter.

**Returns:** A UnaryOperator which takes in one value and returns it.

Below is the code to illustrate accept() method:

**Program 1:**

`import` `java.util.function.UnaryOperator;` ` ` `public` `class` `GFG {` ` ` `public` `static` `void` `main(String args[])` ` ` `{` ` ` ` ` `// Instantiate the UnaryOperator interface` ` ` `UnaryOperator<Boolean>` ` ` `op = UnaryOperator.identity();` ` ` ` ` `// Apply identify() method` ` ` `System.out.println(op.apply(` `true` `));` ` ` `}` `}` |

**Output:**

true

**Below are few examples to demonstrate the methods inherited from Function<T, T>:**

**1.accept()**

`import` `java.util.function.Function;` `import` `java.util.function.UnaryOperator;` ` ` `public` `class` `GFG {` ` ` `public` `static` `void` `main(String args[])` ` ` `{` ` ` `UnaryOperator<Integer> xor = a -> a ^ ` `1` `;` ` ` `System.out.println(xor.apply(` `2` `));` ` ` `}` `}` |

**Output:**

3

**2.addThen()**

`import` `java.util.function.Function;` `import` `java.util.function.UnaryOperator;` ` ` `public` `class` `GFG {` ` ` `public` `static` `void` `main(String args[])` ` ` `{` ` ` `UnaryOperator<Integer> xor = a -> a ^ ` `1` `;` ` ` `UnaryOperator<Integer> and = a -> a & ` `1` `;` ` ` `Function<Integer, Integer> compose = xor.andThen(and);` ` ` `System.out.println(compose.apply(` `2` `));` ` ` `}` `}` |

**Output:**

1

**3.compose()**

`import` `java.util.function.Function;` `import` `java.util.function.UnaryOperator;` ` ` `public` `class` `GFG {` ` ` `public` `static` `void` `main(String args[])` ` ` `{` ` ` `UnaryOperator<Integer> xor = a -> a ^ ` `1` `;` ` ` `UnaryOperator<Integer> and = a -> a & ` `1` `;` ` ` `Function<Integer, Integer> compose = xor.compose(and);` ` ` `System.out.println(compose.apply(` `231` `));` ` ` `}` `}` |

**Output:**

0