Operador unario de Java con ejemplos

Los operadores constituyen el componente básico de cualquier lenguaje de programación. Java también proporciona muchos tipos de operadores que se pueden usar de acuerdo con la necesidad de realizar varios cálculos y funciones, ya sean lógicos, aritméticos, relacionales, etc. Se clasifican según la funcionalidad que brindan. Aquí hay algunos tipos:

1. Operadores aritméticos
2. Operadores unarios
3. Operador de asignación
4. Operadores relacionales
5. Operadores logicos
6. Operador Ternario
7. Operadores bit a bit
8. Operadores de Turno

Operadores unarios en Java

Los operadores unarios de Java son los tipos que necesitan solo un operando para realizar cualquier operación como incremento, decremento, negación, etc. Consta de varios operadores aritméticos, lógicos y otros que operan en un solo operando. Veamos en detalle los distintos operadores unarios y veamos cómo funcionan. 

Operador 1: unario menos (-)

Este operador se puede utilizar para convertir un valor positivo en uno negativo. 

Sintaxis: 

~(operand)

Ilustración: 

a = -10

Ejemplo:

// Java Program to Illustrate Unary - Operator
 
// Importing required classes
import java.io.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring a custom variable
        int n1 = 20;
 
        // Printing the above variable
        System.out.println("Number = " + n1);
 
        // Performing unary operation
        n1 = -n1;
 
        // Printing the above result number
        // after unary operation
        System.out.println("Result = " + n1);
    }
}

Number = 20
Result = -20

Operador 2: Operador ‘NO’ (!)

Esto se utiliza para convertir verdadero a falso o viceversa. Básicamente, invierte el estado lógico de un operando.

Sintaxis: 

!(operand)

Ilustración: 

cond = !true;
// cond < false

Ejemplo:

// Java Program to Illustrate Unary NOT Operator
 
// Importing required classes
import java.io.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Initializing variables
        boolean cond = true;
        int a = 10, b = 1;
 
        // Displaying values stored in above variables
        System.out.println("Cond is: " + cond);
        System.out.println("Var1 = " + a);
        System.out.println("Var2 = " + b);
 
        // Displaying values stored in above variables
        // after applying unary NOT operator
        System.out.println("Now cond is: " + !cond);
        System.out.println("!(a < b) = " + !(a < b));
        System.out.println("!(a > b) = " + !(a > b));
    }
}

Cond is: true
Var1 = 10
Var2 = 1
Now cond is: false
!(a < b) = true
!(a > b) = false

Operador 3: Incremento(++)

Se utiliza para incrementar el valor de un número entero. Se puede utilizar de dos maneras distintas: 

3.1: Operador posincremento

Cuando se coloca después del nombre de la variable, el valor del operando se incrementa pero el valor anterior se retiene temporalmente hasta la ejecución de esta instrucción y se actualiza antes de la ejecución de la siguiente instrucción. 

Sintaxis: 

num++

Ilustración: 

num = 5
num++ = 6

3.2: Operador de incremento previo

Cuando se coloca antes del nombre de la variable, el valor del operando se incrementa instantáneamente.

Sintaxis: 

++num

Ilustración: 

num = 5
++num = 6

Operador 4: Decremento(–)

Se utiliza para decrementar el valor de un número entero. Se puede utilizar de dos maneras distintas: 

4.1: Operador post-decremento

Cuando se coloca después del nombre de la variable, el valor del operando se reduce, pero los valores anteriores se retienen temporalmente hasta la ejecución de esta instrucción y se actualizan antes de la ejecución de la siguiente instrucción. 

Sintaxis: 

num--

Ilustración: 

num = 5
num-- = 4

4.2: Operador de pre-decremento

Cuando se coloca antes del nombre de la variable, el valor del operando se reduce instantáneamente. 

Sintaxis: 

--num

Ilustración:

num = 5
--num = 4

Operador 5: Complemento bit a bit (~)

Este operador unario devuelve la representación en complemento a uno del valor de entrada u operando, es decir, con todos los bits invertidos, lo que significa que hace que cada 0 sea 1 y cada 1 sea 0. 

Sintaxis: 

~(operand)

Ilustración: 

a = 5 [0101 in Binary]
result = ~5

This performs a bitwise complement of 5
~0101 = 1010 = 10 (in decimal)

Then the compiler will give 2’s complement
of that number.
2’s complement of 10 will be -6.
result = -6

Ejemplo:

// Java program to Illustrate Unary
// Bitwise Complement Operator
 
// Importing required classes
import java.io.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring a variable
        int n1 = 6, n2 = -2;
 
        // Printing numbers on console
        System.out.println("First Number = " + n1);
        System.out.println("Second Number = " + n2);
 
        // Printing numbers on console after
        // performing bitwise complement
        System.out.println(
            n1 + "'s bitwise complement = " + ~n1);
        System.out.println(
            n2 + "'s bitwise complement = " + ~n2);
    }
}

First Number = 6
Second Number = -2
6's bitwise complement = -7
-2's bitwise complement = 1