Operadores unarios de incremento y decremento en Java

Operadores unarios

Los operadores unarios son aquellos operadores en Java que solo necesitan un solo operando para realizar cualquier función. Trabajan con el mismo principio que las operaciones unarias en matemáticas. Por ejemplo, puede usar operadores unarios para representar un valor positivo, un valor negativo, incrementar un valor en 1, disminuir un valor en 1 o negar un valor.

• +x (valor positivo)
• -x (valor negativo)
• ++x (operación de incremento)
• --x (operación decremento)
• !x (negación)

Tipos de operadores unarios

Hay 5 tipos de operadores unarios

1. Unario más

Representa un valor positivo como +x = x o +5 = 5.

2. Menos unario

Representa un valor negativo como -x = -x o -5 = -5.

3. Operador incremental unario

Incrementa el valor en 1 donde ++x = x+1.

4. Operador de decremento unario

Decrementa el valor en 1 donde --x = x-1.

5. Complemento lógico

Invierte lógicamente el valor de un valor booleano como si x = verdadero, entonces !x será falso.

Operador de incremento (++)

El operador de incremento (++) (también conocido como operador de incremento unario) en Java se usa para aumentar el valor de una variable en 1. Dado que es un tipo de operador unario, se puede usar con un solo operando.

Sintaxis

La sintaxis del operador de incremento es un par de signos de suma, es decir; El operador se puede aplicar antes o después de la variable. Ambos tendrán el mismo incremento de 1. Sin embargo, ambos tienen usos separados y se pueden clasificar en los siguientes tipos.

• Operador Pre-Incremento
• Operador Post-Incremento

Ejemplo

public class IncrementOperator {

	public static void main(String[] args) {

		int variable = 15;
		System.out.println("Original value of the variable = " + variable);

		// after using increment operator
		variable++; 	 //  increments 1, variable = 16
		System.out.println("variable++ = " + variable);

		++variable;		//  increments 1, variable = 17
		System.out.println("++variable = " + variable);
	}
}

Producción

Operador Pre-Incremento (++x;)

Si el operador de incremento (++) se especifica antes de la variable como un prefijo (++x), entonces se llama operador de preincremento. En este caso, el valor de la variable primero se incrementa en 1 y luego se realizan más cálculos.

Ejemplo

public class PreIncrementOperator {

	public static void main(String[] args) {

		int variable = 5;
		System.out.println("Original value of the variable = " + variable);

		// using pre-increment operator
		int preIncrement = ++variable;

		System.out.println("variable = " + variable);
		System.out.println("preIncrement = " + preIncrement);
		System.out.println("++preIncrement = " + ++preIncrement);
	}
}

Producción

Operador Post-Incremento (x++;)

Si el operador de incremento (++) se especifica después de la variable como un sufijo (x++), entonces se llama operador de incremento posterior. En este caso, el valor original de la variable (sin incremento) se utiliza para los cálculos y luego se incrementa en 1.

Ejemplo

public class PostIncrementOperator {

	public static void main(String[] args) {

		int variable = 100;
		System.out.println("Original value of the variable = " + variable);

		// using post-increment operator
		int postIncrement = variable++; // postIncrement = 100, variable = 101

		System.out.println("postIncrement = " + postIncrement);
		System.out.println("variable = " + variable + "\n");

            // postIncrement = 101
		System.out.println("postIncrement++ = " + postIncrement++);
            // postIncrement = 102
		System.out.println("postIncrement++ = " + postIncrement++);
            // postIncrement = 103
		System.out.println("postIncrement++ = " + postIncrement++);

		System.out.println("\npostIncrement = " + postIncrement);
	}
}

Producción

Operador de decremento (--)

El decremento, como su nombre lo indica, se usa para reducir el valor de una variable en 1. También es uno de los tipos de operadores unarios, por lo que se puede usar con un solo operando.

Sintaxis

La sintaxis del operador decremento es un par de signos negativos, es decir; Al igual que el operador de incremento, el operador de decremento (--) también se puede aplicar antes y después de la variable. Ambos darán como resultado el mismo decremento de 1. Ambos tienen usos distintos y pueden divergir en otros tipos.

• Operador de pre-decremento
• Operador posterior al decremento

Operador de predecremento (--x;)

Si el operador de decremento (--) se menciona antes de la variable como un prefijo (--x), entonces se denomina operador de pre-decremento. Para este caso, el valor de la variable primero se decrementa en 1 y luego se realizan otros cálculos.

Ejemplo

public class PreDecrementOperator {

	public static void main(String[] args) {

		int variable = 11;
		System.out.println("Original value of the variable = " + variable);

		// using preDecrement operator
		int preDecrement = --variable;

            // variable = 10
		System.out.println("variable = " + variable);
            // preDecrement = 10
		System.out.println("preDecrement = " + preDecrement);
            // preDecrement = 9
		System.out.println("--preDecrement = " + --preDecrement);  	}
}

Producción

Operador Post-Decremento (x--;)

Si el operador de decremento (--) se menciona después de la variable como un sufijo (x--), entonces se denomina operador de decremento posterior. Para este caso, se utiliza el valor original de la variable (sin decremento) para los cálculos y luego se decrementa en 1.

Ejemplo

public class PostDecrementOperator {

	public static void main(String[] args) {

		int variable = 75;
		System.out.println("Original value of the variable = " + variable);

		// using postDecrement operator
            // postDecrement = 75, variable = 74
		int postDecrement = variable--;
		System.out.println("postDecrement = " + postDecrement);
		System.out.println("variable = " + variable + "\n");
		// postDecrement = 74
		System.out.println("postDecrement-- = " + postDecrement--);
            // postDecrement = 73
		System.out.println("postDecrement-- = " + postDecrement--);
            // postDecrement = 72
		System.out.println("postDecrement-- = " + postDecrement--);

		System.out.println("\npostDecrement = " + postDecrement);
	}
}

Conclusión

Al final de esta publicación, esperamos que se haya familiarizado con los operadores unarios de incremento y decremento en Java. Lo alentamos a que practique los casos límite y otros problemas de práctica en CodeGym para tener confianza en sus habilidades. Para reforzar lo que aprendió, le sugerimos que vea una lección en video de nuestro Curso de Java

¡Buena suerte y feliz aprendizaje!