## Operadores

Los operadores realizan algunas funciones en uno o dos operandos. Los operadores que requieren un operador se llaman operadores unarios. Por ejemplo, ++ es un operador unario que incrementa el valor su operando en uno.

Los operadores que requieren dos operandos se llaman operadores binarios. El operador = es un operador binario que asigna un valor del operando derecho al operando izquierdo.

Los operadores unarios en Java pueden utilizar la notación de prefijo o de sufijo. La notación de prefijo significa que el operador aparece antes de su operando:

operador operando

La notación de sufijo significa que el operador aparece después de su operando:

operando operador

Todos los operadores binarios de Java tienen la misma notación, es decir aparencen entre los dos operandos:

op1 operator op2

Además de realizar una operación también devuelve un valor. El valor y su tipo dependen del tipo del operador y del tipo de sus operandos. Por ejemplo, los operadores aritméticos (realizan las operaciones de aritmética básica como la suma o la resta) devuelven números, el resultado típico de las operaciones aritmétcias. El tipo de datos devuelto por los operadores aritméticos depende del tipo de sus operandos: si sumas dos enteros, obtendrás un entero. Se dice que una operación evalúa su resultado.

Es muy útil dividir los operadores Java en las siguientes categorías: aritméticos, relacionales y condicionales. lógicos y de desplazamiento y de asignación.

### Operadores Aritméticos

> El lenguaje Java soporta varios operadores aritéticos - incluyendo + (suma), - (resta), * (multiplicación), / (división), y % (módulo)-- en todos los números enteros y de coma flotante. Por ejemplo, puedes utilizar este código Java para sumar dos números:

> sumaEsto + aEsto

> O este código para calcular el resto de una división:

> divideEsto % porEsto

> Esta tabla sumariza todas las operaciones aritméticas binarias en Java:

> Operador | Uso | Descripción
> + | op1 + op2 | Suma op1 y op2
> - | op1 - op2 | Resta op2 de op1
> * | op1 * op2 | Multiplica op1 y op2
> / | op1 / op2 | Divide op1 por op2
> % | op1 % op2 | Obtiene el resto de dividir op1 por op2

> Nota: El lenguaje Java extiende la definición del operador + para incluir la concatenación de cadenas.

> Los operadores + y - tienen versiones unarias que seleccionan el signo del operando:

> Operador | Uso | Descripción
> + | + op | Indica un valor positivo
> - | - op | Niega el operando

> Además, existen dos operadores de atajos aritméticos, ++ que incrementa en uno su operando, y -- que decrementa en uno el valor de su operando.

> Operador | Uso | Descripción
> ++ | op ++ | Incrementa op en 1; evalúa el valor antes de incrementar
> ++ | ++ op | Incrementa op en 1; evalúa el valor después de incrementar
> -- | op -- | Decrementa op en 1; evalúa el valor antes de decrementar
> -- | -- op | Decrementa op en 1; evalúa el valor después de decrementar

### Operadores Relacionales y Condicionales

> Los valores relacionales comparan dos valores y determinan la relación entre ellos. Por ejemplo, != devuelve true si los dos operandos son distintos.

> Esta tabla sumariza los operadores relacionales de Java:

> Operador | Uso | Devuelve true si
> > | op1 > op2 | op1 es mayor que op2
> >= | op1 >= op2 | op1 es mayor o igual que op2
> < | op1 < op2 | op1 es menor que op2
> <= | op1 <= op2 | op1 es menor o igual que op2
> == | op1 == op2 | op1 y op2 son iguales
> != | op1 != op2 | op1 y op2 son distintos

> Frecuentemente los operadores relacionales se utilizan con otro juego de operadores, los operadores condicionales, para construir expresiones de decisión más complejas. Uno de estos operadores es && que realiza la operación Y booleana . Por ejemplo puedes utilizar dos operadores relacionales diferentes junto con && para determinar si ambas relaciones son ciertas. La siguiente línea de código utiliza esta técnica para determinar si un indice de un array está entre dos límites- esto es, para determinar si el indice es mayor que 0 o menor que NUM_ENTRIES (que se ha definido préviamente como un valor constante):

> 0 < index && index < NUM_ENTRIES

> Observa que en algunas situaciones, el segundo operando de un operador relacional no será evaluado. Consideremos esta sentencia:

> ((count > NUM_ENTRIES) && (System.in.read() != -1))

> Si count es menor que NUM_ENTRIES, la parte izquierda del operando de && evalúa a false. El operador && sólo devuelve true si los dos operandos son verdaderos. Por eso, en esta situación se puede deteminar el valor de && sin evaluar el operador de la derecha. En un caso como este, Java no evalúa el operando de la derecha. Así no se llamará a System.in.read() y no se leerá un carácter de la entrada estandard.

> Aquí tienes tres operadores condicionales:

> Operador | Uso | Devuelve true si
> && | op1 && op2 | op1 y op2 son verdaderos
> || | op1 || op2 | uno de los dos es verdadero
> ! | ! op | op es falso

> El operador & se puede utilizar como un sinónimo de && si ambos operadores son booleanos. Similarmente, | es un sinonimo de || si ambos operandos son booleanos.

### Operadores de Desplazamiento

> Los operadores de desplazamiento permiten realizar una manipualción de los bits de los datos. Esta tabla sumariza los operadores lógicos y de desplazamiento disponibles en el lenguaje Java:

> Operador | Uso | Descripción
> >> | op1 >> op2 | desplaza a la derecha op2 bits de op1
> << | op1 << op2 | desplaza a la izquierda op2 bits de op1
> >>> | op1 >>> op2 | desplaza a la derecha op2 bits de op1(sin signo)
> & | op1 & op2 | bitwise and
> | | op1 | op2 | bitwise or
> ^ | op1 ^ op2 | bitwise xor
> ~ | ~ op | bitwise complemento

> Los tres operadores de desplazamiento simplemente desplazan los bits del operando de la izquierda el número de posiciones indicadas por el operador de la derecha. Los desplazamientos ocurren en la dirección indicada por el propio operador. Por ejemplo:

> 13 >> 1;

> desplaza los bits del entero 13 una posición a la derecha. La representación binaria del número 13 es 1101. El resultado de la operación de desplazamiento es 110 o el 6 decimal. Observe que el bit situado más a la derecha desaparece. Un desplazamiento a la derecha de un bit es equivalente, pero más eficiente que, dividir el operando de la izquierda por dos. Un desplazamiento a la izquierda es equivalente a multiplicar por dos.

> Los otros operadores realizan las funciones lógicas para cada uno de los pares de bits de cada operando. La función "y" activa el bit resultante si los dos operandos son 1.

> op1 | op2 | resultado
> 0 | 0 | 0
> 0 | 1 | 0
> 1 | 0 | 0
> 1 | 1 | 1

> Supon que quieres evaluar los valores 12 "and" 13:

> 12 & 13

> El resultado de esta operación es 12. ¿Por qué? Bien, la representación binaria de 12 es 1100 y la de 13 es 1101. La función "and" activa los bits resultantes cuando los bits de los dos operandos son 1, de otra forma el resultado es 0. Entonces si colocas en línea los dos operandos y realizas la función "and", puedes ver que los dos bits de mayor peso (los dos bits situados más a la izquierda de cada número) son 1 así el bit resultante de cada uno es 1. Los dos bits de menor peso se evalúan a 0 poque al menos uno de los dos operandos es 0:

>         	1101
>       & 	1100
>     	------
>     	1100

El operador | realiza la operación O inclusiva y el operador ^ realiza la operación O exclusiva. O inclusiva significa que si uno de los dos operandos es 1 el resultado es 1.

op1 | op2 | resultado
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 1

O exclusiva significa que si los dos operandos son diferentes el resultado es 1, de otra forma el resultado es 0:

op1 | op2 | resultado
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 0

Y finalmente el operador complemento invierte el valor de cada uno de los bites del operando: si el bit del operando es 1 el resultado es 0 y si el bit del operando es 0 el resultado es 1.

### Operadores de Asignación

> Puedes utilizar el operador de asignación =, para asignar un valor a otro. Además del operador de asignación básico, Java proporciona varios operadores de asignación que permiten realizar operaciones aritmétcias, lógicas o de bits y una operación de asignación al mismo tiempo. Especificamente, supon que quieres añadir un número a una variable y asignar el resultado dentro de la misma variable, como esto:

> i = i + 2;

> Puedes ordenar esta sentencia utilizando el operador +=.

> i += 2;

> Las dos líneas de código anteriores son equivalentes.

> Esta tabla lista los operadores de asignación y sus equivalentes:

> Operador | Uso | Equivale a
> += | op1 += op2 | op1 = op1 + op2
> -= | op1 -= op2 | op1 = op1 - op2
> *= | op1 *= op2 | op1 = op1 * op2
> /= | op1 /= op2 | op1 = op1 / op2
> %= | op1 %= op2 | op1 = op1 % op2
> &= | op1 &= op2 | op1 = op1 & op2
> |= | op1 |= op2 | op1 = op1 | op2
> ^= | op1 ^= op2 | op1 = op1 ^ op2
> <<= | op1 <<= op2 | op1 = op1 << op2
> >>= | op1 >>= op2 | op1 = op1 >> op2
> >>>= | op1 >>>= op2 | op1 = op1 >>> op2

Ozito