Todos los Operadores en Java con Ejemplos

Se detalla con ejemplos todos los tipos de operadores que existen en Java. Como por
ejemplo: Operadores relacionales, aritméticos, lógicos, de asignación, entre otros.

Java proporciona muchos tipos de operadores que se pueden usar según la necesidad. Se clasifican
según la funcionalidad que brindan. Algunos de los tipos son los siguientes:

 Operadores aritméticos
 Operadores unarios
 Operador de asignación
 Operadores relacionales
 Operadores lógicos
 Operador ternario
 Operadores bit a bit
 Operadores shift
 Operador de instancia
 Precedencia y Asociatividad de Operadores

Vamos a echarles un vistazo en detalle a cada uno de ellos.

Table de Contenido
 1. Operadores aritméticos
 2. Operadores unarios
 3. Operador de asignación (=)
 4. Operadores relacionales
 5. Operadores lógicos
 6. Operador ternario
 7. Operadores bit a bit
 8. Operadores shift
 9. Operador de Instancia (instanceof)
 10. Precedencia de Operadores
 Extra: Secuencias de Escape en Java
1. Operadores aritméticos
Se utilizan para realizar operaciones aritméticas simples en tipos de datos primitivos.

 *: Multiplicación
 /: División
 %: Modulo
 +: Adición
 –: Resta

Ejemplo:

1. // Programa Java para ilustrar

2. // operadores aritméticos
3. public class operators
4. {
5. public static void main(String[] args)
6. {
7. int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
8. String x = "Thank", y = "You";
9.
 10. // Operador + y -
11. System.out.println("a + b = "+(a + b));
12. System.out.println("a - b = "+(a - b));
13.
14. // El operador + si se usa con strings
15. // concatena las cadenas dadas.
16. System.out.println("x + y = "+x + y);
17.
18. // Operador * y /
19. System.out.println("a * b = "+(a * b));
20. System.out.println("a / b = "+(a / b));
21.
22. // operador de módulo da el resto
23. // de dividir el primer operando con el segundo
24. System.out.println("a % b = "+(a % b));
25.
26. // si el denominador es 0 en la división
27. // System.out.println(a/c);
28. // lanzaría una java.lang.ArithmeticException
29.
30. }
31. }
Salida:

a + b = 30
a - b = 10
x + y = ThankYou
a * b = 200
a / b = 2
a % b = 0

2. Operadores unarios
Los operadores unarios solo necesitan un operando. Se usan para incrementar, disminuir o negar un
valor.

 –: Unario menos, utilizado para negar los valores.

 +: Unario más, usado para dar valores positivos. Solo se usa cuando se convierte
deliberadamente un valor negativo en positivo.
 ++: Operador de incremento, utilizado para incrementar el valor en 1. Hay dos variedades
de operador de incremento.

1. Pre-Incremento: el valor se incrementa primero y luego se calcula el resultado.

2. Post-Incremento: el valor se usa por primera vez para calcular el resultado y luego se
incrementa.

 —: Operador de decremento , usado para incrementar el valor en 1. Hay dos variedades de

operador de incremento.

1. Pre-Decremento: el valor se disminuye primero y luego se calcula el resultado.

2. Post-Decremento: el valor se usa por primera vez para calcular el resultado y luego se
disminuye.
  ! : Operador lógico “no”, utilizado para invertir un valor booleano.

Ejemplo:

1. // Programa Java para ilustrar

2. // operadores unarios
3. public class operators
4. {
5. public static void main(String[] args)
6. {
7. int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
8. boolean condition = true;
9.
10. // operador de pre-incremento
11. // a = a+1 y entonces c = a;
12. c = ++a;
13. System.out.println("Valor de c (++a) = " + c);
14.
15. // operador de post-incremento
16. // c=b entonces b=b+1 (b pasa a ser 11)
17. c = b++;
18. System.out.println("Valor de c (b++) = " + c);
19.
20. // operador de pre-decremento
21. // d=d-1 entonces c=d
22. c = --d;
23. System.out.println("Valor de c (--d) = " + c);
24.
25. // operador de post-decremento
26. // c=e entonces e=e-1 (e pasa a ser 39)
27. c = e--;
28. System.out.println("Valor de c (e--) = " + c);
29.
30. // Operador lógico not
31. System.out.println("Valor de !condition = " + !condition);
32.
33. }
34. }
Salida:

Valor de c (++a) = 21
Valor de c (b++) = 10
Valor de c (--d) = 19
Valor de c (e--) = 40
Valor de !condition = false

3. Operador de asignación (=)

El operador de asignación se usa para asignar un valor a cualquier variable. Tiene una asociación de
derecha a izquierda, es decir, el valor dado en el lado derecho del operador se asigna a la variable de
la izquierda y, por lo tanto, el valor del lado derecho debe declararse antes de usarlo o debe ser una
constante.

El formato general del operador de asignación es, variable = valor;

En muchos casos, el operador de asignación se puede combinar con otros operadores para construir
una versión más corta de la declaración llamada Declaración Compuesta (Compound Statement).
Por ejemplo, en lugar de a = a + 5, podemos escribir a + = 5.
int a = 5;
a += 5; // a = a + 5;

 + = , para sumar el operando izquierdo con el operando derecho y luego asignarlo a la
variable de la izquierda.
 – = , para restar el operando izquierdo con el operando derecho y luego asignarlo a la
variable de la izquierda.
 * = , para multiplicar el operando izquierdo con el operando derecho y luego asignándolo a
la variable de la izquierda.
 / = , para dividir el operando izquierdo con el operando derecho y luego asignarlo a la
variable de la izquierda.
 ^ = , para aumentar la potencia del operando izquierdo al operando derecho y asignarlo a la
variable de la izquierda.
 % = , para asignar el módulo del operando izquierdo con el operando derecho y luego
asignarlo a la variable de la izquierda.

Ejemplo:

1. // Programa Java para ilustrar

2. // Operadores de Asignación
3. public class operators
4. {
5. public static void main(String[] args)
6. {
7. int a = 20, b = 10, c, d, e = 10, f = 4, g = 9;
8.
9. // operador de asignación simple
10. c = b;
11. System.out.println("Valor de c = " + c);
12.
13. // Esta siguiente declaración arrojaría una exception
14. // porque el valor del operando derecho debe ser inicializado
15. // antes de la asignación, entonces el programa no
16. // compila.
17. // c = d;
18.
19. // operadores de asignación simples
20. a = a + 1;
21. b = b - 1;
22. e = e * 2;
23. f = f / 2;
24. System.out.println("a,b,e,f = " + a + ","
25. + b + "," + e + "," + f);
26. a = a - 1;
27. b = b + 1;
28. e = e / 2;
29. f = f * 2;
30.
31. // operados de asignación compuestos/cortos
32. a += 1;
33. b -= 1;
34. e *= 2;
35. f /= 2;
36. System.out.println("a,b,e,f (usando operadores cortos)= " +
37. a + "," + b + "," + e + "," + f);
38. }
39. }
Salida:
Valor de c = 10
a,b,e,f = 21,9,20,2
a,b,e,f (usando operadores cortos)= 21,9,20,2

4. Operadores relacionales
Estos operadores se utilizan para verificar relaciones como igualdad, mayor que, menor que.
Devuelven el resultado booleano después de la comparación y se usan ampliamente en
las instrucciones de bucle, así como en las sentencias condicionales if/else. El formato general
es, variable operador_relacion valor

Algunos de los operadores relacionales son:

 ==, Igual a: devuelve verdadero si el valor del lado izquierdo es igual al lado derecho.
 ! =, No igual a: devuelve verdadero si el valor del lado izquierdo no es igual al lado
derecho.
 <, menos que: el resultado verdadero si el valor del lado izquierdo es inferior al del lado
derecho.
 <=, menor o igual que: devuelve verdadero si el valor del lado izquierdo es menor o igual
que el lado derecho.
 >, Mayor que: devuelve verdadero si el valor del lado izquierdo es mayor que el lado
derecho.
 > =, Mayor que o igual a: regresa verdadero si el valor del lado izquierdo es mayor o igual
que el lado derecho.

Ejemplo:

1. // Programa Java para ilustrar

2. // operadores relacionales
3. public class operators
4. {
5. public static void main(String[] args)
6. {
7. int a = 20, b = 10;
8. String x = "Thank", y = "Thank";
9. int ar[] = { 1, 2, 3 };
10. int br[] = { 1, 2, 3 };
11. boolean condicion = true;
12.
13. //varios operadores condicionales
14. System.out.println("a == b :" + (a == b));
15. System.out.println("a < b :" + (a < b));
16. System.out.println("a <= b :" + (a <= b));
17. System.out.println("a > b :" + (a > b));
18. System.out.println("a >= b :" + (a >= b));
19. System.out.println("a != b :" + (a != b));
20.
21. // Los Arrays no se pueden comparar con
22. // operadores relacionales porque los objetos
23. // almacenan referencias, mas no el valor
24. System.out.println("x == y : " + (ar == br));
25.
26. System.out.println("condicion==true :" + (condicion == true));
27. }
28. }
Salida:
a == b :false
a < b :false
a <= b :false
a > b :true
a >= b :true
a != b :true
x == y : false
condicion==true :true

5. Operadores lógicos
Estos operadores se utilizan para realizar operaciones “lógicas AND” y “lógicas OR”, es decir, la
función similar a la puerta AND y la puerta OR en electrónica digital. Una cosa a tener en cuenta es
que la segunda condición no se evalúa si la primera es falsa, es decir, tiene un efecto de
cortocircuito. Se usa ampliamente para probar varias condiciones para tomar una decisión.

Los operadores condicionales son:

 &&, AND lógico: devuelve verdadero cuando ambas condiciones son verdaderas.
 || , O lógico: devuelve verdadero si al menos una condición es verdadera.

Ejemplo:

1. // Programa Java para ilustrar

2. // operadores logicos
3. import java.util.Scanner;
4.
5. public class operators
6. {
7. public static void main(String[] args)
8. {
9. String x = "java";
10. String y = "desdecero";
11.
12. Scanner s = new Scanner(System.in);
13. System.out.print("Ingrese usuario:");
14. String uuid = s.next();
15. System.out.print("Ingrese contraseña:");
16. String upwd = s.next();
17.
18. // Verifique si el nombre de usuario y la contraseña coinciden o no.
19. if ((uuid.equals(x) && upwd.equals(y)) ||
20. (uuid.equals(y) && upwd.equals(x))) {
21. System.out.println("Bienvenido usuario.");
22. } else {
23. System.out.println("ID o Contraseña equivocada");
24. }
25.
26. }
27. }
Salida:
Ingrese usuario:java
Ingrese contraseña:desdecero
Bienvenido usuario.

6. Operador ternario
Ternario es una versión abreviada de la declaración if-else. Tiene tres operandos y de ahí el nombre
ternario. El formato general es: condicion ? if true : if false
La declaración anterior significa que si la condición se evalúa como verdadera, entonces ejecuta las
instrucciones después del ‘?‘ de lo contrario, ejecuta las instrucciones después de ‘:‘.

Ejemplo:

1. // Programa Java para ilustrar

2. // el máximo de tres números utilizando
3. // operador ternario.
4. public class operators
5. {
6. public static void main(String[] args)
7. {
8. int a = 20, b = 10, c = 30, result;
9.
10. //el resultado obtiene el máximo de tres
11. //numeros
12. result = ((a > b) ? (a > c) ? a :
13. c : (b > c) ? b : c);
14. System.out.println("Máximo de tres números = "+result);
15. }
16. }
Salida:

Máximo de tres números = 30

7. Operadores bit a bit

Los operadores a nivel de bits se utilizan para realizar la manipulación de bits individuales de un
número. Se pueden usar con cualquiera de los tipos enteros. Se utilizan al realizar operaciones de
actualización y consulta de árbol indexado binario.

 &, Operador bit a bit AND: Si ambos bits de entrada son 1, establece el resultado en 1. De

lo contrario da como resultado 0. El resultado binario final se muestra en decimal.
 | , Operador bit a bit OR: Si al menos uno de los dos bits de entrada es 1, establece el
resultado en 1. De lo contrario da como resultado 0. El resultado binario final se muestra en
decimal.
 ^, Operador bit a bit XOR: Si uno de los bits de entrada es 0 y el otro 1, el resultado es 1.
Si ambos bits comparados son iguales, el resultado es 0. El resultado binario final se
muestra en decimal.
 ~, Operador bit a bit de complemento (NOT): este es un operador unario que devuelve la
representación complementaria del valor de entrada, es decir, con todos los bits
invertidos. El resultado binario final se muestra en decimal.

Ejemplo:
 1. // Programa Java para ilustrar
2. // operadores bit a bit (bitwise)
3. public class operators
4. {
5. public static void main(String[] args)
6. {
7.
8. int a = 0x0005;
9. int b = 0x0007;
10.
11. // bitwise AND
12. // 0101 & 0111=0101
13. System.out.println("a&b = " + (a & b));
14.
15. // bitwise or
16. // 0101 | 0111=0111
17. System.out.println("a|b = " + (a | b));
18.
19. // bitwise xor
20. // 0101 ^ 0111=0010
21. System.out.println("a^b = " + (a ^ b));
22.
23. // bitwise complemento
24. // ~0101=1010
25. System.out.println("~a = " + ~a);
26.
27. // también se puede combinar con el
28. // operador de asignación
29. // a=a&b
30. a &= b;
31. System.out.println("a= " + a);
32. }
33. }
Salida:

a&b = 5
a|b = 7
a^b = 2
~a = -6
a= 5

8. Operadores shift
Los operadores shift de Java se usan para desplazar los bits de un número hacia la izquierda o hacia
la derecha, multiplicando o dividiendo el número por dos, respectivamente. Se pueden usar cuando
tenemos que multiplicar o dividir un número por dos.

 <<, operador de desplazamiento a la izquierda : desplaza los bits del número hacia la
izquierda y llena con “0” los bits desplazados. Efecto similar a la multiplicación del número
con una potencia de dos.
 >>, Operador de desplazamiento a la derecha firmado: desplaza los bits del número a la
derecha y llena con “0” los bits desplazados. El bit más a la izquierda depende del signo del
número inicial. Efecto similar a partir de dividir el número con alguna potencia de dos.
 >>>, Operador de cambio a la derecha sin signo: desplaza los bits del número a la
derecha y llena con “0” los bits desplazados. El bit más a la izquierda se establece en 0.

Ejemplo:
 1. // Programa Java para ilustrar
2. // operadores shift
3. public class operators
4. {
5. public static void main(String[] args)
6. {
7.
8. int a = 0x0005;
9. int b = -10;
10.
11. // operador de desplazamiento a la izquierda
12. // 0000 0101<<2 =0001 0100(20)
13. // similar a 5*(2^2)
14. System.out.println("a<<2 = " + (a << 2));
15.
16. // operador de desplazamiento a la derecha
17. // 0000 0101 >> 2 =0000 0001(1)
18. // similar a 5/(2^2)
19. System.out.println("a>>2 = " + (a >> 2));
20.
21. // operador de cambio a la derecha sin firmar
22. System.out.println("b>>>2 = "+ (b >>> 2));
23.
24. }
25. }
Salida:

a<<2 = 20
a>>2 = 1
b>>>2 = 1073741821

9. Operador de Instancia (instanceof)

El operador de instancia se usa para verificar el tipo. Se puede usar para probar si un objeto es una
instancia de una clase, una subclase o una interfaz.

Formato general:  objecto instanceof class/subclass/interface

Ejemplo:

1. // Programa Java para ilustrar

2. // instancia de operador
3. class operators
4. {
5. public static void main(String[] args)
6. {
7.
8. Person obj1 = new Person();
9. Person obj2 = new Boy();
10.
11. // Como obj1 es de tipo Person, no es una
12. // instancia de Boy o interfaz
13. System.out.println("obj1 instanceof Person: " +
14. (obj1 instanceof Person));
15. System.out.println("obj1 instanceof Boy: " +
16. (obj1 instanceof Boy));
17. System.out.println("obj1 instanceof MyInterface: " +
18. (obj1 instanceof MyInterface));
19.
20. // Dado que obj2 es de tipo Boy, cuya clase padre es
21. // Person e implementa la interfaz Myinterface
 22. // es una instancia de todas estas clases
23. System.out.println("obj2 instanceof Person: " +
24. (obj2 instanceof Person));
25. System.out.println("obj2 instanceof Boy: " +
26. (obj2 instanceof Boy));
27. System.out.println("obj2 instanceof MyInterface: " +
28. (obj2 instanceof MyInterface));
29. }
30. }
31.
32. class Person
33. {
34.
35. }
36.
37. class Boy extends Person implements MyInterface
38. {
39.
40. }
41.
42. interface MyInterface
43. {
44.
45. }
Salida:

obj1 instanceof Person: true

obj1 instanceof Boy: false
obj1 instanceof MyInterface: false
obj2 instanceof Person: true
obj2 instanceof Boy: true
obj2 instanceof MyInterface: true

×Nota: No se preocupe si no entiende, lo veremos más adelante en detalle. Sin embargo, es bueno
que conozca que existe este tipo de operador. 

10. Precedencia de Operadores

La precedencia y las reglas asociativas se usan cuando se trata de ecuaciones híbridas que involucran
a más de un tipo de operador. En tales casos, estas reglas determinan qué parte de la ecuación
considerar primero, ya que puede haber muchas valoraciones diferentes para la misma ecuación. La
siguiente tabla muestra la precedencia de los operadores en orden decreciente como magnitud, con la
parte superior representando la precedencia más alta y la inferior con la prioridad más baja.

Tabla de Precedencia y asociatividad de los operadores en Java.

Operador Aociatividad

++ — De derecha a izquierda
 Tabla de Precedencia y asociatividad de los operadores en Java.

Operador Aociatividad

++ — + – ! De derecha a izquierda

*/% De derecha a izquierda

+– De derecha a izquierda

< <= > >= De derecha a izquierda

== != De derecha a izquierda

& De derecha a izquierda

^ De derecha a izquierda

| De derecha a izquierda

&& De derecha a izquierda

|| De derecha a izquierda

?: De derecha a izquierda

= += -= *= /= %= De derecha a izquierda

Extra: Secuencias de Escape en Java

Los valores numéricos y de texto en los programas de Java se conocen como “literales”; no
representan nada, pero son, literalmente, lo que ves.

Los literales normalmente se desprenden de las palabras clave del lenguaje Java, pero cuando se
requieren comillas dobles o comillas simples dentro de un valor de String, es necesario indicar que el
carácter de cita debe tratarse LITERALMENTE para evitar terminar prematuramente el String. Esto
se logra fácilmente mediante el prefijo inmediato de cada carácter de comillas anidado con el
operador de escape \.

Me explico mejor con el siguiente ejemplo:

String cita = " \"Java debe ser un territorio neutral, la Suiza de la

tecnología informática.\"dijo James Gosling";

Además, el operador de escape \ ofrece una variedad de secuencias de escape muy útiles como son
los siguientes:

Tabla de Secuencias de Escape en Java.

Escape Descripción

\n Nueva Linea.

\t Tabulador.

\b Backspace

\r Retorno del carro.

\f Form feed.

\\ Barra invertida (\)

\’ Comilla simple

\” Comilla doble

×Nota: Tanto \r como \f son caracteres de control de terminal o impresora y no tienen ningún

significado en Java.
Ejemplo de Escape:

1. class Escape {
2.
3. public static void main( String[] args ) {
 4.
5. String cabecera = "\n\tPRONOSTICO DE CLIMA:\n" ;
6. cabecera += "\n\tDia\t\tMañana\tNoche\tCondiciones\n" ;
7. cabecera += "\t---\t\t-------\t----\t-----------\n" ;
8.
9. String pronostico = "\tDomingo\t25C\t\t23C\t\tSoleado\n";
10. pronostico += "\tLunes\t24C\t\t19C\t\tSoleado\n";
11. pronostico += "\tMartes\t26C\t\t15C\t\tNublado\n";
12.
13. System.out.print(cabecera+pronostico) ;
14. }
15. }
Salida:

Ejemplo de Escape en Java

Puede consultar más información en la Documentación Oficial de Java, o, dejarnos un comentario
con cualquiera de sus dudas 🙂