1.9 Operadores y expresiones

Operadores Aritméticos

Los Operadores Aritméticos permiten realizar operaciones matemáticas:

Operador	Uso	Operación
+	A + B	Suma
-	A - B	Resta
*	A * B	Multiplicación
/	A / B	División
%	A % B	Módulo o resto de una división entera

Ejemplo:

double num1, num2, suma, resta, producto, division, resto;
num1 =8;
num2 =5;
suma = num1 + num2;      // 13
resta = num1 - num2;     // 3
producto = num1 * num2;  // 40
division = num1 / num2;  // 1.6
resto = num1 % num2;     // 3

Operadores Relacionales

Los Operadores Relacionales permiten evaluar (la respuesta es un booleano: sí o no) la igualdad de los operandos:

Operador	Uso	Operación
<	A < B	A menor que B
>	A > B	A mayor que B
<=	A <= B	A menor o igual que B
>=	A >= B	A mayor o igual que B
!=	A != B	A distinto de B
==	A == B	A igual a B

Por ejemplo:

int valor1 = 10;
int valor2 = 3;
boolean compara;
compara = valor1 > valor2;  // true
compara = valor1 < valor2;  // false
compara = valor1 >= valor2; // true
compara = valor1 <= valor2; // false
compara = valor1 == valor2; // false
compara = valor1 != valor2; // true

Operadores Lógicos

Los Operadores Lógicos permiten realizar operaciones lógicas:

Operador	Manejo	Operación
&& o &	A && B ó A & B	A AND B. El resultado será true si ambos operadores son true y false en caso contrario.
|| o |	A || B ó A | B	A OR B. El resultado será false si ambos operandos son false y true en caso contrario
!	!A	NOT A. Si el operando es true el resultado es false y si el operando es false el resultado es true.
^	A ^ B	A XOR B. El resultado será true si un operando es true y el otro false, y false en caso contrario.

Ejemplo:

double sueldo = 1400;
int edad = 34;
boolean logica;

logica = (sueldo>1000 & edad<40);   //true
logica = (sueldo>1000 && edad>40);  //false
logica = (sueldo>1000 | edad>40);   //true
logica = (sueldo<1000 || edad>40);  //false
logica = !(edad<40);                //false
logica = (sueldo>1000 ^ edad>40);   //true
logica = (sueldo<1000 ^ edad>40);   //false

Para representar resultados de operadores Lógicos también se pueden usar tablas de verdad a las que conviene acostumbrarse:

A	B	A && B	A || B	!A
false	false	false	false	true
true	false	false	true	false
false	true	false	true	true
true	true	true	true	false

Operadores Unarios o Unitarios

Los Operadores Unarios o Unitarios permiten realizar incrementos y decrementos:

Operador	Uso	Operación
++	A++ o ++A	Incremento de A
--	A-- o --A	Decremento de A

Ejemplo:

int m = 5, n = 3;
m++; // 6
n--; // 2

En el caso de utilizarlo como prefijo el valor de asignación será el valor del operando más el incremento de la unidad. Y si lo utilizamos como sufijo se asignará el valor del operador y luego se incrementará la unidad sobre el operando.

int A = 1, B;
B = ++A; // A vale 2 y B vale 2
B = A++; // A vale 3 y B vale 2

Operadores de Asignación

Los Operadores de Asignación permiten asignar valores:

Operador	Uso	Operación
=	A = B	Asignación (como ya hemos visto)
+=	A += B	Suma y asignación. La operación A+=B equivale a A=A+B
-=	A -= B	Resta y asignación. La operación A-=B equivale a A=A-B
*=	A *= B	Multiplicación y asignación. La operación A*=B equivale a A=A*B
%=	A %= B	Módulo y asignación. La operación A%=B equivale a A=A%B
/=	A /= B	División y asignación. La operación A/=B equivale a A=A/B

Ejemplo:

int dato1 = 10, dato2 = 2, dato;
dato=dato1;   // dato vale 10
dato2+=dato1; // dato2 vale 12
dato2-=dato1; // dato2 vale 2
dato2*=dato1; // dato2 vale 20
dato2/=dato1; // datos2 vale 2
dato1%=dato2; // dato1 vale0

Prioridad de operadores

Los operadores tienen diferente Prioridad por lo que es interesante utilizar paréntesis para controlar las operaciones sin necesidad de depender de la prioridad de los operadores.

Operadores de desplazamiento

Los Operadores de desplazamiento permiten desplazar los bits de los valores:

Operador	Utilización	Resultado
<<	A << B	Desplazamiento de A a la izquierda en B posiciones. Multiplica por 2 el número B de veces.
>>	A >> B	Desplazamiento de A a la derecha en B posiciones, tiene en cuenta el signo. Divide por 2 el número B de veces.
>>>	A >>> B	Desplazamiento de A a la derecha en B posiciones, no tiene en cuenta el signo. (simplemente agrega ceros por la izquierda)
&	A & B	Operación AND a nivel de bits
|	A | B	Operación OR a nivel de bits
^	A ^ B	Operación XOR a nivel de bits
~	~A	Complemento de A a nivel de bits

Ejemplo:

int j = 33;
int k = j << 2;
// 00000000000000000000000000100001 : j = 33
// 00000000000000000000000010000100 : k = 33 << 2 ; k = 132

int o = 132;
int p = o >> 2;
// 00000000000000000000000010000100 : o = 132    
// 00000000000000000000000000100001 : p = 132 >> 2 ; p = 33

int x = -1;
int y = x >>> 2;
// 11111111111111111111111111111111 : x = -1
// 00111111111111111111111111111111 : y = x >>> 2; y = 1073741823

int q = 132;   // q: 00000000000000000000000010000100
int r = 144;   // r: 00000000000000000000000010010000

int s = q & r; // s: 00000000000000000000000010000000 
// El resultado da 128 

int t = q | r; // t: 00000000000000000000000010010100 
// El resultado da 148

int u = q ^ r; // u: 00000000000000000000000000010100 
// El resultado da 20 

int v = ~q;    // v: 11111111111111111111111101111011 
// El resultado da -133 

Operador condicional ?:

El operador condicional ?: sirve para evaluar una condición y devolver un resultado en función de si es verdadera o falsa dicha condición. Es el único operador ternario de Java, y como tal, necesita tres operandos para formar una expresión:

• El primer operando se sitúa a la izquierda del símbolo de interrogación, y siempre será una expresión booleana, también llamada condición.
• El siguiente operando se sitúa a la derecha del símbolo de interrogación y antes de los dos puntos, y es el valor que devolverá el operador condicional si la condición es verdadera.
• El último operando, que aparece después de los dos puntos, es la expresión cuyo resultado se devolverá si la condición evaluada es falsa.

condición ? exp1 : exp2

Ejemplo, en la expresión:

(x>y)?x:y;

Se evalúa la condición de si x es mayor que y, en caso afirmativo se devuelve el valor de la variable x, y en caso contrario se devuelve el valor de y.

Ejemplo para calcular qué número es mayor:

int mayor, exp1 = 15, exp2 = 25;
mayor=(exp1>exp2)?exp1:exp2;
// mayor valdrá 25

El operador condicional se puede sustituir por la sentencia if...then...else que veremos más adelante.

Prevalencia de operadores

Los operadores tienen diferente Prioridad por lo que es interesante utilizar paréntesis para controlar las operaciones sin necesidad de depender de la prioridad de los operadores.

Prevalencia de operadores, ordenados de arriba a abajo de más a menos prioridad:

Descripción	Operadores
operadores posfijos	op++ op--
operadores unarios	++op --op +op -op ~ !
multiplicación y división	* / %
suma y resta	+ -
desplazamiento	<< >> >>>
operadores relacionales	< > <= =>
equivalencia	== !=
operador AND	&
operador XOR	^
operador OR	|
AND booleano	&&
OR booleano	||
condicional	?:
operadores de asignación	= += -= *= /= %= &= ^= |= <<= >>= >>>=

Ejemplo:

int x, y1 = 6, y2 = 2, y3 =8;
x = y1 + y2 * y3;   // 22
x = (y1 + y2) * y3; // 64