Los operadores permiten realizar cálculos, comparaciones y operaciones lógicas sobre los datos de un programa. Son una parte fundamental de cualquier lenguaje de programación ya que mediante ellos podemos crear expresiones aritméticas, relacionales, lógicas, etc. con los datos del programa. En esta entrada se explican los operadores que proporciona el lenguaje Java con ejemplos prácticos de uso de cada uno de ellos. Primero se mostrará una tabla con todos los operadores Java y a continuación se explicará cada uno de ellos.

La siguiente tabla muestra todos los operadores del lenguaje Java

Los operadores aritméticos en Java son los siguientes:

Los operadores suma, resta y multiplicación funcionan igual que lo hacen en matemáticas. El resultado que se obtiene al operar con ellos en un programa Java coincide con el de la operación matemática equivalente.

Los operadores división y módulo en Java pueden producir resultados distintos a los que obtendríamos en matemáticas. El resultado dependerá de los tipos de datos que intervienen en la operación.

Operador división /

Para obtener el resultado del operador división en Java debemos tener en cuenta lo siguiente:

• Si los dos operandos son de tipo entero (tipos byte, short, int, long, char) el operador división devuelve un entero. No se obtienen decimales. El resultado de la división de dos enteros es la parte entera de la división sin decimales.
• Si alguno de los operandos es de tipo real (tipo float o double) el resultado que se obtiene es de tipo real. El resultado de la división se obtiene con decimales. No es necesario que ambos operandos sean reales, con que uno de ellos lo sea es suficiente para obtener decimales en la división.

Por ejemplo, al ejecutar las siguientes instrucciones:

int a = 7, b = 2;
System.out.println(a / b);

Se muestra por pantalla 3

Las variables a y b son de tipo int por lo tanto el resultado de la división entre ellas es de tipo int. No se obtienen decimales.

En este otro ejemplo:

int a = 7;
double b = 2;
System.out.println(a / b);

Se muestra por pantalla 3.5

La variable a es de tipo int y b es de tipo double. En este caso el resultado de la división se obtiene con decimales.

Operador módulo o resto de la división %

Para obtener el resultado del operador % en Java debemos tener en cuenta lo siguiente:

• Si los dos operandos son de tipo entero (tipos byte, short, int, long, char) el operador módulo devuelve un entero. No se obtienen decimales. El valor del resto de la división, cuando los dos operandos son de tipo entero, se obtiene de esta forma:

resto = dividendo - divisor * cociente

• Si alguno de los operandos es de tipo real (tipo float o double) el resultado que se obtiene es de tipo real. El resultado se obtiene con decimales. No es necesario que ambos operandos sean reales, con que uno de ellos lo sea es suficiente para obtener decimales en el resto de la división. El valor del resto de la división, cuando algún operando o los dos son de tipo real, se obtiene de esta forma:

resto = dividendo – divisor * parte entera del cociente

Por ejemplo, al ejecutar las siguientes instrucciones:

int a = 7, b = 2;
System.out.println(a % b);

Se muestra por pantalla 1

Las variables a y b son de tipo int por lo tanto el módulo o resto de la división entre ellas es de tipo int. No se obtienen decimales.

Si calculamos el módulo cuando una variable es de tipo double, por ejemplo:

int a = 9;
double b = 2.5;
System.out.println(a % b);

Se muestra por pantalla 1.5

La variable a es de tipo int y b de tipo double. En este caso el módulo de la división se obtiene con decimales. Para calcularlo se ha aplicado la fórmula

resto = dividendo – divisor * parte entera del cociente

resto = 9 – 2.5 * 3   ->   resto = 1.5

Cuando en una expresión intervienen distintos operadores, unos se deben evaluar antes que otros. El orden de precedencia indica en qué orden se evalúan los operadores que aparecen en una expresión.

El orden de prededencia para los operadores ariméticos en Java es el siguiente:

• Primero se evalúan los operadores multiplicación * división / y módulo % Estos operadores tienen entre sí la misma precedencia y se evalúan de izquierda a derecha.
• Después se evalúan los operadores suma + y resta - Estos operadores tienen entre sí la misma precedencia y se evalúan de izquierda a derecha.

Veamos ahora cómo se utilizan los operadores aritméticos en Java y el resultado que obtenemos al operar con variables de distinto tipo. Para ello utilizaremos variables de tipo int, double y char.

Supongamos que tenemos las siguientes variables:

int a = 10, b = 3;
double v1 = 12.5, v2 = 2.0;
char c1='P', c2='T';

En la tabla se muestran distintas operaciones aritméticas que podemos hacer con ellas y los resultados que se obtienen al aplicar los operadores aritméticos:

En las operaciones aritméticas donde intervienen variables de tipo char, el valor usado para realizar el cálculo es el valor numérico del carácter correspondiente según la tabla ASCII o UNICODE en su caso.

Por eso, según vemos en el ejemplo: c1 + c2 = 164
c1 = ‘P’ y el valor numérico de ‘P’ según la tabla ASCII es 80.
c2 = ‘T’ y el valor numérico de ‘T’ según la tabla ASCII es 84.
Por lo tanto cuando realizamos c1 + c2 el resultado es 80 + 84 = 164

Más ejemplos en la entrada Ejercico sobre operadores aritméticos Java

Como ya se ha comentado en la entrada Tipos de Datos, Java es un lenguaje fuertemente tipado. Por eso es importante saber de qué tipo es el resultado de una operación aritmética cuando intervienen datos de tipos distintos.

En aquellas operaciones aritméticas en las que aparecen operandos de distinto tipo, java convierte los valores al tipo de dato de mayor precisión de todos los datos que intervienen y este será el tipo del resultado. Esta conversión se realiza de forma temporal, solamente para realizar la operación. Los tipos de datos originales permanecen igual después de la operación. Esto es muy importante tenerlo en cuenta para poder asignar el resultado de la operación a una variable del mismo tipo.

Por ejemplo, si tenemos las siguientes variables:

int i = 7;
double f = 5.5;
char c = 'w';
byte b = 1;
long ln = 10;

vamos a realizar operaciones aritméticas con ellas y obtener el tipo del resultado de la operación.

En la tabla se puede ver el resultado que se obtiene al realizar operaciones entre ellas y de qué tipo es este resultado (double, int, char, etc)

Más ejemplos en la entrada Calcular el tipo del resultado en operaciones aritméticas Java.

Los operadores relacionales comparan dos operandos y dan como resultado de la comparación true o false. Los operandos tienen que ser de tipo primitivo.

Los operadores relacionales en Java son los siguientes:

Cuando en una expresión Java aparecen varios ordedores relacionales, el orden de precedencia es el siguiente:

• Primero se evalúan los operadores < <= > >= Estos operadores tienen entre sí la misma precedencia y se evalúan de izquierda a derecha.
• Después se evalúan los operadores == != Estos operadores tienen entre sí la misma precedencia y se evalúan de izquierda a derecha.

A partir de las siguientes variables:

int a = 7, b = 9, c = 7;

vamos a realizar distintas operaciones de comparación con ellas utilizando los operadores relacionales.

Más ejemplos en la entrada Ejercicios sobre los operadores relacionales en Java

Los operadores lógicos se utilizan con operandos de tipo boolean. Se utilizan para construir expresiones lógicas, cuyo resultado es true o false.

Los operadores lógicos en Java son los siguientes:

Las definiciones de las operaciones AND &&, OR || y NOT ! se recogen en unas tablas conocidas como tablas de verdad.

Si en una expresión Java contiene varios operadores lógcos, el orden de precedencia es el siguiente:

• Primero se evalúan los operadores NOT !
• Después se evalúan los operadores AND && Si hay varios se evalúan de izquierda a derecha
• Por último los operadores OR || Si hay varios se evalúan de izquierda a derecha

Disponemos de las siguientes variables:

int i = 7;
float f = 5.5F;
char c = ‘w’;

En la tabla siguiente se muestran una serie de expresiones lógicas con esas variables y su valor

Las expresiones lógicas se evalúan sólo hasta que se ha establecido el valor cierto o falso del conjunto. Cuando, por ejemplo, una expresión va a ser seguro falsa por el valor que ha tomado uno de sus operandos, java ya no evalúa el resto de expresión.

Más ejemplos en la entrada Ejercicio sobre operadores lógicos en Java.

Los operadores unarios afectan a un solo operando.

Los operadores unarios en Java son los siguientes:

Los operadores + y - además de operadores aritméticos, pueden actuar como operadores unarios, es decir, operadores que se aplican a un solo operando. En este caso se denominan operadores de signo y sirven para indicar o modificar el signo de un valor numérico.

Estos operadores se pueden utilizar con valores numéricos tanto enteros (byte, short, int, long) como reales (float, double).

El operador unario + (signo positivo) no modifica el signo del operando. Su función es simplemente indicar que el valor es positivo.

Por ejemplo:

int x = +10;  // el valor de x es 10
int y = +x; //el valor de y es 10

int x = -10;  // el valor de x es -10
int y = +x; //el valor de y es -10
El operador unario + no modifica el signo por lo tanto el valor de y es -10

El uso del operador unario + es opcional y en la práctica no se suele usar ya que no modifica el valor del operando.

El operador unario – (signo negativo) cambia el signo del valor al que se aplica:

• Si el operando es positivo lo cambia a negativo
• Si el operando es negativo lo cambia a positivo

Por ejemplo:

int x = -10;  // el valor de x es -10
int y = -x; //el valor de y es 10

int x = 10;  // el valor de x es 10
int y = -x; //el valor de y es -10

El operador ++ (operador incremento) incrementa en 1 el valor de la variable.

Ejemplo:

int i = 1;
i++; // Esta instrucción incrementa en 1 el valor de la variable i.
System.out.println(i); //muestra por consola 2

La instrucción i++ equivale a realizar la instrucción i = i + 1

El operador - - (operador decremento) decrementa en 1 el valor de la variable.

Ejemplo:

int i = 1;
i--; // Esta instrucción decrementa en 1 el valor de la variable i.
System.out.println(i); //muestra por consola 0

La instrucción i-- equivale a realizar la instrucción i = i - 1

Los operadores Java incremento y decremento pueden utilizarse como prefijo o postfijo, es decir, pueden aparecer antes o después de la variable.

Por ejemplo, el operador incremento ++ los podemos utilizar en la versión preincremento o postincremento según aparezca el operador antes o después de la variable.

Lo mismo ocurre con el operador decremento -- que podemos utilizarlo en sus versiones predecremento o postdecremento.

Por ejemplo:

int x, i = 3;
x = i++;

En la instrucción x = i++ se usa el operador postincremento, por lo tanto la variable se incrementará después de evaluar la expresión, en este caso después de realizar la asignación x = i.

Primero se asigna a x el valor de i (3) y a continuación se incrementa la variable i, por lo tanto, después de ejecutar la instrucción los valores de x e i son:

x = 3

i = 4

Si las instrucciones son:

int x, i = 3;
x = ++i;

En este caso en la instrucción x = ++i se usa el operador preincremento, por lo tanto la variable se incrementará antes de evaluar la expresión, en este caso antes de realizar la asignación x = i.

Primero se incrementa el valor de i (4) y después se asigna este valor de i a x. Después de ejecutar la instrucción los valores de las variables son:

x = 4

i = 4

Si la operación de incremento/decremento de una variable se realiza de forma individual, es decir, no forma parte de una expresión con más operaciones, es este caso se puede usar la versión prefijo o la versión postfijo. En ambos casos el resultado será incrementaren 1 el valor de la variable.

Por ejemplo, si tenemos una variable n y solo queremos incrementar su valor podemos escribir:

n++;   //operador postincremento

o también podemos utilizar el operador preincremento:

++n;   //operador preincremento

En ambos casos el resultado es el mismo, se incrementa en 1 el valor de n.

Ejemplo 1: Tenemos las siguientes instrucciones:

int i = 1;
System.out.println(i);
System.out.println (++i);
System.out.println (i);

Cuando se ejecutan, la salida por consola será esta:

1
2
2

En la instrucción System.out.println (++i); se utiliza el operador preincremento por lo que primero se suma 1 al valor de i y después se muestra por pantalla.

Ejemplo 2: Tenemos las siguientes instrucciones:

int i = 1;
System.out.println(i);
System.out.println (i++);
System.out.println (i);

Al ejecutar las instrucciones se produce esta salida por consola:

1
1
2

En la instrucción System.out.println (i++); se utiliza el operador postincremento por lo que primero se muestra el valor actual de i y después se incrementa.

Ejemplo 3: Tenemos las siguientes instrucciones:

int i = 1;
System.out.println(++i);
System.out.println (++i);
System.out.println (i++);
System.out.println (i);

Cuando se ejecutan la salida por pantalla es:

2
3
3
4

La instrucción System.out.println(++i); primero incrementa i y después muestra el valor. i = 2 y se muestra 2

La instrucción System.out.println(++i); primero incrementa i y después muestra el valor. i = 3 y se muestra 3

La instrucción System.out.println(i++); primero muestra el valor de i y después lo incrementa. muestra 3 y i = 4

La instrucción System.out.println(i); muestra el valor de i. muestra 4

Puedes encontrar más ejemplos en la entrada Ejercicios con los operadores incremento y decremento en Java

El operador unario ~ es el operador complemento a 1, a veces también llamado operador NOT a nivel de bits. Su función es invertir todos los bits de un número entero.

Es un operador de bajo nivel que afecta a un solo operando y forma parte de los operadores a nivel de bits o operadores bitwise que se exponen de forma resumida en el punto siguiente y se explican de forma extensa en el tema Operadores Java a nivel de bits.

El operador NOT es un operador unario que forma parte de los operadores lógicos explicados en un punto anterior.

Los operadores a nivel de bits, también llamados operadores bitwise, son operadores de bajo nivel que se utiliza para trabajar bit a bit con la representación binaria de los datos.

Son operadores que no suelen aparecer en programas básicos ni en programas avanzados de gestión. Los operadores bitwise se suelen usar en:

• Programación de bajo nivel
• Optimización de memoria
• Programación de sistemas
• Motores gráficos
• Drivers
• Compresión de datos
• Criptografía
• Tratamiento de permisos o estados

Los operadores Java a nivel de bits son los siguientes:

Los operadores a nivel de bits o operadores bitwise se explican ampliamente en el tema Operadores Java a nivel de bits.

Los operadores de asignación en Java permiten almacenar valores en variables y modificar su contenido a lo largo de la ejecución del programa. El operador de asignación más básico es el signo igual = que asigna un valor a una variable, pero Java también incorpora operadores de asignación compuesta que combinan una operación aritmética o una operación bit a bit con la asignación en una sola expresión. En este punto se explican todos los operadores de asignación en Java con ejemplos de funcionamiento.

Los operadores Java de asignación son los siguientes:

Todos los operadores de asignación compuesta:

variable operador= expresión;

Equivalen a:

variable = variable operador expresión;

A partir de las declaraciones de variables:

int i = 5, j = 7, k = 9, w = 2, x = 2, y = 2, z = 5;
double f = 5.5, g = -3.25, h = 10.5;

En la tabla se muestran ejemplos de operaciones de asignación y el valor final que se le asigna a la variable en cada una de ellas:

Por ejemplo:

int n;
double m = 2.5;
n = m + 1;

Al intentar realizar la asignación n = m + 1 se producirá un error ya que el resultado de la operación m + 1 es de tipo double y no se puede asignar a una variable de tipo int.

Si las instrucciones son estas:

double m;
int n = 2;
m = n + 50;

En este caso la asignación m = n + 50; se puede realizar ya que el resultado de la operación n + 50 es de tipo int y la variable m es de tipo double. Aunque ambos tipos no coinciden, la asignación se puede realizar porque el rango de un int es menor que el de un double y por lo tanto no hay pérdida de información

En general, en una asignación del tipo A = B, si el rango de valores que puede almacenar A es mayor que el rango de valores que puede almacenar B (puedes consultar el rango de cada tipo en el tema Tipos de datos en Java) entonces la asignación se podrá realizar. Por ejemplo, si A es de tipo double y B de tipo float la asignación A = B se puede hacer pero no se podrá realizar en el caso contrario (siendo A float y B double).

En Java se pueden realizar operaciones de asignación múltiple. La asignación múltiple se produce cuando en una misma expresión se asignan valores a varias variables encadenando la asignaciones mediante el operador =.

Por ejemplo:

a = b = c = 3; 

La asignación del valor a las variables en una asignación múltiple se realiza de derecha a izquierda. En el ejemplo, primero se asigna a c el valor 3, a continuación el valor de c se asigna a b y finalmente el valor de b se le asigna a la variable a.

Es equivalente a realizar:

c = 3; 
b = c; 
a = b;

o lo que es lo mismo:

a = 3; 
b = 3; 
c = 3;

Mediante las asignaciones múltiples podemos obtener un código más compacto aunque en ocasiones puede llevar a confusión. Si estamos empezando con el lenguaje Java es preferible realizar las asignaciones por separado porque se obtiene un código más legible.

El operador de asignación = en Java se puede utilizar tanto con tipos de datos primitivos como con objetos aunque su funcionamiento no es el mismo en ambos casos.

Cuando trabajamos con tipos primitivos, en la asignación se copia el valor de la expresión en la variable. Por ejemplo:

int x = 10;    // a la variable x se le asigna el valor 10
int y = x;     // a la variable y se le asigna el valor 10 

A la variable y se le asigna el valor que contiene la variable x en ese momento. Si posteriormente cambia el valor de x, el valor de y no se modifica.

int x = 10;    // a la variable x se le asigna el valor 10
int y = x;     // a la variable y se le asigna el valor 10 
x = 0;         // a la variable x se le asigna el valor 0
System.out.println(x); // muestra 0
System.out.println(y); // muestra 10 Si modificamos el valor de x, el valor de y no cambia 

Sin embargo, cuando trabajamos con objetos, en la asignación se copia la referencia del objeto en la variable. Por ejemplo:

Persona p1 = new Persona("Ernesto");
Persona p2 = p1;

A la variable p2 no se le asigna una copia del objeto. A la variable p2 se le asigna la referencia del objeto p1. Esto quiere decir tanto p1 como p2 apuntan al mismo objeto. Si modificamos el objeto mediante la variable p1 el cambio se verá también si accedemos al objeto mediante la variable p2.

Los operadores de asignación compuestos se suelen usar solamente con tipos de datos primitivos.

Con objetos solo se pueden usar si el operador tiene sentido para ese tipo. Un ejemplo típico es el uso del operador += con el tipo String.

String mensaje = "Hola";
mensaje += " mundo!!";

El operador + con Strings es el operador concatenación para unir cadenas de caracteres. Equivale a:

String mensaje = "Hola";
mensaje = mensaje + " mundo!!";

El operador ternario, también llamado operador condicional, permite tomar una decisión simple dentro de una expresión. Se usa como alternativa de la sentencia de control if-else para elegir entre dos valores.

El operador condicional o ternario lo forman los caracteres ? :

La sintaxis general del operador ternario es:

El operador ternario funciona de la siguiente forma:

• Primero se evalúa la condición
• Si la condición es true el operador devuelve el valor que aparece entre los caracteres ? y :
• Si la condición es false devuelve el valor que aparece a continuación del carácter :

El operador ternario se explica de forma amplia en el tema Operador ternario en Java donde puedes encontrar ejemplos de uso incluyendo ejemplos de operadores ternarios anidados.

Cuando en una expresión aparecen varios operadores, unos se evalúan antes que otros, siguiendo las reglas de precedencia de los operadores que determina el lenguaje.

El orden de precedencia o orden de prioridad de los operadores determina el orden en el que se evalúan.

En la tabla se muestran los operadores Java ordenados de mayor a menor precedencia. Los operadores que aparecen en un mismo nivel tienen la misma preferencia entre ellos.

En la tabla también se muestra la asociatividad de los operadores. Cuando en una expresión aparecen operadores que tienen la misma prioridad, la asociatividad indica en qué orden se ejecutan esos operadores. En general los operadores con la misma precedencia se ejecutan de izquierda a derecha, salvo algunos operadores que se indican en la tabla.

Orden de precedencia de los operadores Java ordenados de mayor precedencia a menor precedencia:

Ejemplo:

int x = 10 - 7 / 3 * 2 + 2 * 8; 

En esta expresión aparecen los operadores + - * /

Los operadores * / tienen más precedencia que los operadores + - por lo tanto, primero se realizarán las multiplicaciones y divisiones y después las sumas y restas.

Los operadores * y / tienen la misma precedencia y su asociatividad indica que se evalúan de izquierda a derecha. Por lo tanto primero se realiza la operación 7 / 3 que da como resultado 2 y después se multiplica por 2. El resultado es 4. A continuación se realiza la operación 2 * 8 que da como resultado 16.

Después se evalúan los operadores + y – Estos operadores tienen la misma precedencia y se evalúan de izquierda a derecha.

El valor que se le asigna a x es 22

int x = 10 - 7 / 3 * 2 + 2 * 8; 
        10 -     4     +  16   
x = 22

Entender la prioridad de operadores en Java no solo evita errores, sino que nos permite escribir código más claro, profesional y mantenible.

Aunque es importante conocer la precedencia, para evitar confusiones a veces es recomendable:

• Usar paréntesis cuando la expresión no sea trivial.
• Priorizar la claridad sobre la concisión.
• Evitar expresiones excesivamente complejas en una sola línea.