# Unary Operator | Java

Unary operators in Java are operators that operate on a single operand. They are used to perform various operations such as incrementing/decrementing a value, negating a value, or inverting the bits of a value. Here are the main unary operators in Java:

1. **Unary Plus (**`+`**):**
    
    * Indicates a positive value. While it doesn't change the sign of positive numbers, it can be used to emphasize the positive sign.
        
    
    ```java
    int x = 5;
    int result = +x; // result is 5
    ```
    
2. **Unary Minus (**`-`**):**
    
    * Negates the value of its operand.
        
    
    ```java
    int y = 8;
    int result = -y; // result is -8
    ```
    
3. **Increment (**`++`**):**
    

* Increases the value of its operand by 1.
    
* ```java
    int a = 3;
    a++; // a is now 4
    ```
    

There are two types of implement operators -

* **Post Increment**: First initialise then increase.
    
* **Pre Increment**: First increase then initialise.
    

**For example** -

| Expression | Initial value of `x` | Value of `y` | Final value |
| --- | --- | --- | --- |
| `y = x++` | 10 | 10 | 11 |
| `y = ++x` | 10 | 11 | 11 |

1. **Decrement (**`--`**):**
    

* Decreases the value of its operand by 1.
    
* ```java
    int b = 7;
    b--; // b is now 6
    ```
    

There are two types of implement operators -

* **Post Increment**: First initialise then increase.
    
* **Pre Increment**: First increase then initialise.
    

**For example** -

| Expression | Initial value of `x` | Initial value of `y` | Final value |
| --- | --- | --- | --- |
| `y = x--` | 10 | 10 | 9 |
| `y = --x` | 10 | 9 | 9 |

It's important to note that the increment and decrement operators can be used as a prefix (`++a` or `--a`) or a postfix (`a++` or `a--`). The difference between the two lies in when the increment or decrement is applied in relation to the surrounding expression.

1. **Logical Complement (**`!`**):**
    

* Inverts the logical state of its operand. If the operand is true, the result is false, and if the operand is false, the result is true.
    
* This operator is only applicable for boolean.
    
* ```java
    boolean flag = true;
    boolean result = !flag; // result is false
    ```
    
* **Bitwise Complement (**`~`**):**
    
    * Inverts the bits of its operand, changing 1s to 0s and vice versa.
        
    * This operator is only applicable for integral not for boolean.
        
* ```java
    int number = 5; // binary: 0000 0000 0000 0000 0000 0000 0000 0101
    int result = ~number; // binary: 1111 1111 1111 1111 1111 1111 1111 1010 (-6 in decimal)
    ```
    

Unary operators are essential in various programming scenarios, and they play a crucial role in expressions and statements. Understanding how these operators work is fundamental for writing efficient and correct Java code.