Introducción a los operadores de Java: lógicos, aritméticos y bit a bit

Hablemos de operaciones en Java: numéricas, lógicas, bit a bit. Esta es una base teórica que definitivamente es necesaria para aprender a programar.

• ¿Cuáles son los tipos de operadores en Java?
• Curso de Operadores Java en JavaRush
• Operaciones numéricas en Java
• Operaciones lógicas en Java
• Operaciones bit a bit en Java
• Prioridad de operaciones en Java
• Ejemplos útiles de uso

¿Cuáles son los tipos de operadores en Java?

Para cualquier operación necesitamos al menos dos cosas:

• operador;
• operando.

Un ejemplo de operador sería un simple plus en la operación de sumar dos números. Y los números sumados entre sí serán operandos en este caso. Entonces, con la ayuda de operadores, realizamos operaciones en uno o más operandos. Los operadores que realizan operaciones sobre dos operandos se llaman binarios. Por ejemplo, sumar dos números. Los operadores que realizan operaciones sobre un único operando se denominan unarios. Por ejemplo, un menos unario.

Curso de Operadores Java en JavaRush

Se dedican varias conferencias a los operadores de Java en el cuarto nivel de la primera misión: la sintaxis de Java. En particular, operadores condicionales como booleanos . El curso contiene 22 tareas que le ayudarán a comprender el trabajo de los operadores de comparación, operadores condicionales y operadores lógicos.

Operaciones numéricas en Java

La operación más común que realizan los programadores con números es asignar un valor numérico a una variable. Ella, como el operador, =te resulta familiar:

int a = 1;
int b = 2;
int c = 3;

También hay operaciones aritméticas. Se realizan mediante operadores aritméticos binarios: Tabla 1. Operadores aritméticos binarios Los primeros cuatro operadores no deberían plantear ninguna duda: todo es igual que en matemáticas. El último operador, el resto de la división, tampoco hace nada demasiado complicado. Por ejemplo, si dividimos 24 entre 7, obtenemos 3 números enteros y 3 restantes. Es el resto que devolverá este operador:

System.out.println(24 % 7); // imprime 3

Aquí hay ejemplos del sitio de documentación oficial de Oracle: Este programa generará lo siguiente: 1 + 2 = 3 3 - 1 = 2 2 * 2 = 4 4 / 2 = 2 2 + 8 = 10 10 % 7 = 3 Java te permite para combinar: por ejemplo, asignaciones de operadores y operadores aritméticos. Veamos un ejemplo:

int x = 0;
x = x + 1; // x = 0 + 1 => x = 1
x = x + 1; // x = 1 + 1 => x = 2
x = x + 1; // x = 2 + 1 => x = 3

Aquí hemos definido una variable xy le hemos asignado un valor de cero. A continuación, en cada línea asignamos un valor xa la suma del valor actual de la variable xy uno. Hay explicaciones en los comentarios para cada línea. Este procedimiento se llama hacer crecer o incrementar una variable. La operación incremental del ejemplo anterior se puede reemplazar por una similar usando una combinación de operadores:

int x = 0;
x += 1; // x = 0 + 1 => x = 1
x += 1; // x = 1 + 1 => x = 2
x += 1; // x = 2 + 1 => x = 3

Puedes combinar el operador de asignación con cualquier operador aritmético:

int x = 0;
x += 10; // x = 0 + 10 => x = 10
x -= 5; // x = 10 - 5 => x = 5
x *= 5; // x = 5 * 5 => x = 25
x /= 5; // x = 25 / 5 => x = 5
x %= 3; // x = 5 % 3 => x = 2;

Demostremos cómo funciona el último ejemplo: Además de los operadores binarios, Java tiene operadores aritméticos unarios. Tabla 2. Operadores aritméticos unarios: Ejemplo de más y menos unario:

int x = 0;
x = (+5) + (+15); // Paréntesis para mayor claridad, es posible sin ellos
System.out.println("x = " + x);

int y = -x;
System.out.println("y = " + y);

Las operaciones de incremento y decremento son esencialmente simples. En el primer caso, la variable se incrementa en 1, en el segundo, la variable se disminuye en 1. El ejemplo es el siguiente:

int x = 9;
x++;
System.out.println(x); // 10

int y = 21;
y--;
System.out.println(y); // 20

Hay dos tipos de estas operaciones: postfijo y prefijo. En el primer caso, el operador se escribe después de la variable, en el segundo caso, antes de la variable. La única diferencia es cuando se realiza la operación de incremento o decremento. Ejemplo y descripción en la siguiente tabla. Digamos que tenemos una variable:

int a = 2;

Entonces: Tabla 3. Operadores de incremento-decremento: Demostración: Además de la aritmética, existen operaciones de comparación (de dos números). El resultado siempre será verdadero o falso ( verdadero / falso ). Tabla 4. Operadores de comparación Ejemplos:

int a = 1;
int b = 2;

boolean comparisonResult = a == b;
System.out.println("a == b :" + comparisonResult);

comparisonResult = a != b;
System.out.println("a != b :" + comparisonResult);

comparisonResult = a > b;
System.out.println("a >  b :" + comparisonResult);

comparisonResult = a >= b;
System.out.println("a >= b :" + comparisonResult);

comparisonResult = a < b;
System.out.println("a <  b :" + comparisonResult);

comparisonResult = a <= b;
System.out.println("a <= b :" + comparisonResult);

Demostración:

Operaciones lógicas en Java

Veamos las operaciones lógicas y tablas de verdad de cada una de ellas:

• operación de negación ( NOT);
• operación de conjunción, lógica AND ( AND);
• operación de disyunción, lógica OR ( OR);
• operación de suma de módulo, OR exclusivo ( XOR).

El operador de negación es unario y se aplica a un único operando. Todas las demás operaciones son binarias. Consideremos las tablas de verdad de estas operaciones. Aquí 0 es el equivalente de false en Java y 1 es el equivalente de true . Tabla 5. Tabla de verdad del operador de negación (NOT) Tabla 6. Tabla de verdad del operador de conjunción (Y) Tabla 7. Tabla de verdad del operador de disyunción (OR) Tabla 8. Tabla de verdad del operador de suma de módulo (XOR) Java tiene las mismas operaciones lógicas:

• !— operador de negación;
• &&— operador lógico AND (corto);
• ||— operador lógico OR (corto);
• &— operador AND bit a bit;
• |— operador OR bit a bit;
• ^— operador OR exclusivo bit a bit.

Veamos la diferencia entre operadores bit a bit y operadores abreviados un poco más abajo, mientras convertimos todas las tablas de verdad a código Java:

public class LogicDemo {

   public static void main(String[] args) {
    notExample();
    andExample();
    orExample();
    xorExample();
   }

   public static void notExample() {
    System.out.println("NOT EXAMPLE:");
    System.out.println("NOT false = " + !false);
       System.out.println("NOT true  = " + !true);
    System.out.println();
   }

   public static void andExample() {
    System.out.println("AND EXAMPLE:");
    System.out.println("false AND false = " + (false & false));
    System.out.println("false AND true  = " + (false & true));
    System.out.println("true  AND false = " + (true & false));
    System.out.println("true  AND true  = " + (true & true));
    System.out.println();
   }

   public static void orExample() {
    System.out.println("OR EXAMPLE:");
    System.out.println("false OR false = " + (false | false));
    System.out.println("false OR true  = " + (false | true));
    System.out.println("true  OR false = " + (true | false));
     System.out.println("true  OR true  = " + (true | true));
    System.out.println();
   }

   public static void xorExample() {
    System.out.println("XOR EXAMPLE:");
    System.out.println("false XOR false = " + (false ^ false));
    System.out.println("false XOR true  = " + (false ^ true));
    System.out.println("true  XOR false = " + (true ^ false));
    System.out.println("true  XOR true  = " + (true ^ true));
    System.out.println();
   }
}

Este programa mostrará: NO EJEMPLO: NO falso = verdadero NO verdadero = falso Y EJEMPLO: falso Y falso = falso falso Y verdadero = falso verdadero Y falso = falso verdadero Y verdadero = verdadero O EJEMPLO: falso O falso = falso falso O verdadero = verdadero verdadero O falso = verdadero verdadero O verdadero = verdadero XOR EJEMPLO: falso XOR falso = falso falso XOR verdadero = verdadero verdadero XOR falso = verdadero verdadero XOR verdadero = falso Los operadores lógicos se aplican solo a booleanvariables. En nuestro caso, los aplicamos directamente a valores, pero también puedes usarlos con booleanvariables: Y a booleanlas expresiones: Ahora, tenemos operadores taquigráficos ( &&, ||) y operadores bit a bit similares ( &, |). ¿Cuál es la diferencia entre ellos? Primero, bit a bit se puede aplicar a números enteros. Hablaremos de esto un poco más tarde. Y en segundo lugar, algunos están abreviados y otros no. Para entender cómo se ve la abreviatura, veamos la expresión:

false AND x = ?
true OR x = ?

Puede xtomar cualquier valor booleano. Y en general, según las leyes de la lógica y las tablas de verdad, independientemente de si es x verdadera o falsa , el resultado de la primera expresión será falso , y el resultado de la segunda será verdadero . Mirar. A veces, el resultado de una expresión se puede calcular a partir del primer operando. Esto es lo que distingue a los operadores abreviados &&y ||. En expresiones similares a las descritas anteriormente, no evalúan el valor del segundo operando. He aquí un pequeño ejemplo: En el caso de operadores taquigráficos, la segunda parte de la expresión no se evalúa. Pero esto sucede sólo cuando el resultado de la expresión ya es obvio desde el primer operando.

Operaciones bit a bit en Java

Bueno, aquí llegamos a la parte más interesante: las operaciones bit a bit. Como sugiere el nombre, se trata de operaciones que se realizan en bits. Pero antes de profundizar en este tema, vale la pena hablar de áreas relacionadas.

Representación de números en el sistema numérico binario.

Los números, como cualquier otra información de un programa, se almacenan en la memoria de la computadora en código binario. El código binario es un conjunto de ceros y unos. Cada cero o uno representa una unidad de información llamada bit.

Según Wikipedia:

Un bit (del dígito binario inglés - número binario; también un juego de palabras: bit inglés - pieza, partícula) es una unidad de medida de la cantidad de información. 1 bit de información es un símbolo o señal que puede asumir dos significados: encendido o apagado, sí o no, alto o bajo, cargado o descargado; en el sistema binario es 1 (uno) o 0 (cero).

¿Con qué tipo de datos trabajan los operadores bit a bit?

Las operaciones bit a bit en Java se realizan sólo con números enteros. Los números enteros se almacenan en la memoria de la computadora como un conjunto de bits. Podemos decir que una computadora convierte cualquier información en un sistema numérico binario (un conjunto de bits) y solo entonces interactúa con él. Pero, ¿cómo funciona el sistema numérico binario? En el sistema numérico decimal tenemos solo 10 símbolos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Usamos estos símbolos para contar. Después del 9 viene el 10, después del 19 - 20, después del 99 - 100, después del 749 - 750. Es decir, utilizamos una combinación de los 10 símbolos disponibles y podemos utilizarlos para contar "desde cero hasta el almuerzo". En el sistema numérico binario, en lugar de diez símbolos, solo hay dos: 0, 1. Pero al combinar estos símbolos según el mismo principio que en el sistema decimal, podemos contar indefinidamente. Demostremos cómo contar del 0 al 15 en decimal y binario: Como puedes ver, no todo es tan complicado. Además de los bits, existen otras unidades de información familiares: bytes , kilobytes , megabytes , gigabytes , etc. Probablemente sepas que hay 8 bits en 1 byte . ¿Qué significa? Esto significa que 8 bits seguidos ocupan 1 byte. A continuación se muestran ejemplos de lo que pueden ser los bytes:

00000000 - 1 byte
10110010 - 1 byte
01011011 - 1 byte

El número de posibles combinaciones de bits no repetidas en un byte es 256 (2 · ⁸ = 256). Pero volvamos más cerca de Java. Existe un tipo de datos entero: byte. Este tipo puede tomar valores de -128 a 127 y un número en la memoria de la computadora ocupa exactamente 8 bits o 1 byte. Un número de este tipo ocupa exactamente 1 bytememoria de computadora. Y aquí los nombres coinciden no por casualidad. Como recordamos, 1 byte puede almacenar 256 valores diferentes. Y un número de tipo bytepuede tomar 256 valores diferentes (128 negativos, 127 positivos y 1 cero). Cada valor numérico bytetiene un conjunto único de ocho bits. Este es el caso no sólo del tipo byte, sino de todos los tipos integrales. El tipo bytese da como ejemplo como el más pequeño. La siguiente tabla muestra todos los tipos de enteros de Java y el espacio de memoria que ocupan: Considere el tipo int. Puede almacenar 2147483648 valores negativos, 2147483647 valores positivos y un cero. Total:

2147483648 + 2147483647 + 1 = 4294967296.

Este tipo ocupa 32 bits en la memoria de la computadora. El número de combinaciones posibles de un conjunto de 32 ceros y unos es:

232 = 4294967296.

El mismo número que el número de valores que puede contener el tipo int. Esta es solo una demostración de la relación entre el rango de valores de un tipo de datos y su tamaño (número de bits en la memoria). Cualquier número de cualquier tipo en Java se puede convertir a binario. Veamos con qué facilidad se puede hacer esto usando el lenguaje Java. Aprenderemos del ejemplo de tipo int. Este tipo tiene su propia clase contenedora: Integer. Y tiene uno toBinaryStringque hará todo el trabajo por nosotros: Listo, no es tan complicado. Pero aún así es necesario aclarar algo. intel número toma 32 bits. Pero cuando imprimimos el número 10 en el ejemplo anterior, vemos 1010 en la consola. Esto se debe a que los ceros iniciales no se imprimen. Si se mostraran, en lugar de 1010 veríamos en la consola 000000000000000000000000000001010. Pero para facilitar la percepción, se omiten todos los ceros iniciales. No es tan difícil hasta que te preguntas: ¿qué pasa con los números negativos? Percibe información sólo en el sistema binario. Resulta que el signo menos también debe escribirse en código binario. Esto se puede hacer mediante código directo o complementario.

código directo

Un método para representar números en el sistema numérico binario, en el que el bit más significativo (el bit más a la izquierda) se asigna al signo del número. Si el número es positivo, el bit más a la izquierda se escribe 0, si es negativo, 1. Veamos esto usando un número de 8 bits como ejemplo: El enfoque es sencillo y, en principio, comprensible. Sin embargo, tiene desventajas: dificultades para realizar operaciones matemáticas. Por ejemplo, con la suma de números negativos y positivos. No se pueden plegar a menos que se realicen manipulaciones adicionales.

código adicional

Al utilizar código adicional, puede evitar las desventajas del código directo. Existe un algoritmo sencillo para obtener el código adicional de un número. Intentemos obtener el código adicional para el número -5. Representemos este número usando el código de complemento a dos en el sistema numérico binario. Paso 1. Obtenemos una representación de un número negativo mediante código directo. Para -5 será 10000101. Paso 2. Invierta todos los dígitos excepto el dígito del signo. Reemplacemos todos los ceros con unos y los unos con ceros en todas partes excepto en el bit más a la izquierda.

10000101 => 11111010

Paso 3. Suma uno al valor resultante:

11111010 + 1 = 11111011

Listo. Obtuvimos el valor de -5 en el sistema numérico binario usando el código complemento a dos. Esto es importante para comprender el siguiente material, ya que Java utiliza código en complemento a dos para almacenar números negativos en bits.

Tipos de operaciones bit a bit

Ahora que hemos abordado todas las introducciones, hablemos de las operaciones bit a bit en Java. Una operación bit a bit se realiza sobre números enteros y su resultado es un número entero. En el proceso, el número se convierte a binario, se realiza una operación en cada bit y el resultado se vuelve a convertir a decimal. La lista de operaciones se encuentra en la siguiente tabla: Como ya hemos descubierto, los números se pueden representar como un conjunto de bits. Las operaciones bit a bit realizan operaciones exactamente en cada bit de dicha representación. Echemos NOT, AND, OR, XOR. Recuerde que recientemente analizamos las tablas de verdad solo para operandos lógicos. En este caso, se aplican las mismas operaciones a cada bit del número entero.

Operador unario bit a bit NO ~

Este operador reemplaza todos los ceros por unos y todos los unos por ceros. Digamos que tenemos el número 10 en notación decimal. En binario, este número es 1010. Si aplicamos el operador unario de negación bit a bit a este número, obtenemos algo como esto: Echemos un vistazo a cómo se ve en el código Java:

public static void main(String[] args) {
   int a = 10;

   System.out.println(" a = " + a + "; binary string: " + Integer.toBinaryString(a));
   System.out.println("~a = " + ~a + "; binary string: " + Integer.toBinaryString(~a));
}

Ahora veamos qué se muestra en la consola: En la primera línea obtuvimos el valor en el sistema numérico binario sin ceros a la izquierda. Aunque no los veamos, están ahí. Esto se evidencia en la segunda línea, en la que todos los bits se transformaron en inversos. Por eso vemos tantas unidades líderes. Estos son antiguos ceros iniciales que el compilador ignoró cuando se imprimieron en la primera línea. Aquí hay un pequeño programa que también muestra ceros a la izquierda para mayor claridad.

Operador AND bit a bit

Este operador se aplica a dos números. Realiza una operación ANDentre los bits de cada número. Veamos un ejemplo: esta operación se realiza con dos números. Ejemplo en código Java:

Operador OR bit a bit

O se aplica a dos números. Realiza una operación OR entre los bits de cada número: ahora echemos un vistazo a cómo se vería esto en IDEA:

Operación bit a bit, OR exclusivo (XOR)

Veamos el mismo ejemplo, pero con una nueva operación: Código de ejemplo:

Desplazamiento bit a izquierda

Este operador es aplicable a dos operandos, es decir, en la operación x << y, los bits del número xse desplazarán yde posición hacia la izquierda. ¿Qué significa? Veamos el ejemplo de la operación, 10 << 1 el resultado de la operación será el número 20 en el sistema decimal. Como puede ver en el diagrama anterior, todos los bits se desplazan 1 a la izquierda. Durante esta operación, se pierde el valor del bit más significativo (el bit más a la izquierda). Y el bit menos significativo (el bit más a la derecha) se llena con cero. ¿Qué puedes decir sobre esta operación?

1. Al desplazar los bits de un número Xbits hacia Nla izquierda, multiplicamos el número Xpor 2 ^N.

   He aquí un ejemplo:

2. ¡Pero! El signo del número puede cambiar si el bit con el valor 1 ocupa la posición más a la izquierda.

3. Si se desplaza hacia la izquierda indefinidamente, el número simplemente se convertirá en 0. Demostremos los puntos 2 y 3:

Desplazamiento bit a bit a la derecha

Este operador se aplica a dos operandos. Aquellos. En la operación x >> y, los bits del número xse desplazarán yde posición hacia la derecha. Veamos otro ejemplo. Analicemos esquemáticamente el funcionamiento 10 >> 1. Desplacemos todos los bits del número 10 una posición hacia la derecha: durante la operación de desplazamiento, perdemos los bits correctos. Simplemente desaparecen. El bit más a la izquierda es el signo del número (0 es positivo, 1 es negativo). Por tanto, en el valor final se coloca igual que en el número original. Ejemplo con un número negativo: el bit más a la derecha se pierde y el bit más a la izquierda se copia del número original, como signo honorífico del número. ¿Cómo hacer todo esto en IDEA? En principio, nada complicado, sólo tómalo y muévelo: Ahora. ¿Qué puedes decir sobre los números que se desplazan hacia la derecha? Son divisibles por 2. Cada vez que nos desplazamos un bit hacia la derecha, dividimos el número original entre 2. Si el número no es divisible por 2, el resultado se redondeará hacia menos infinito (hacia abajo). Pero esto sólo funciona si desplazamos los bits exactamente 1. Y si son 2 bits, dividimos entre 4. Si son 3 bits, dividimos entre 8. Si son 4 bits, dividimos entre 16. ¿Ves? Potencias de 2... Cuando desplazamos un número Xhacia Nla derecha en bits, dividimos el número Xentre 2 elevado a 2 N. Demostración:

public class BitOperationsDemo {

   public static void main(String[] args) {

    for (int i = 1; i <= 10; i++) {

        int shiftOperationResult = 2048 >> i;
        int devideOperationResult = 2048 / (int) Math.pow(2, i);


           System.out.println(shiftOperationResult + " - " + devideOperationResult);
    }

   }

}

¿Que está pasando aqui?

1. Un bucle en el que la variable i se incrementa de 1 a 10.

2. En cada iteración calculamos 2 valores:

• Escribimos en la variable shiftOperationResultel resultado de desplazar el número 2048 i bits hacia la derecha;

• devideOperationResultEscribimos el resultado de dividir el número 2048 entre 2 elevado a i en una variable .

3. Mostramos los dos valores obtenidos por parejas.

El resultado de ejecutar el programa es el siguiente: 1024 - 1024 512 - 512 256 - 256 128 - 128 64 - 64 32 - 32 16 - 16 8 - 8 4 - 4 2 - 2

Desplazamiento bit a derecha con relleno cero

Mientras que un desplazamiento normal a la derecha conserva el signo del número (el bit más significativo conserva su valor), un desplazamiento a la derecha con relleno de ceros no lo hace. Y el bit más significativo se llena con cero. Veamos cómo se ve:

Prioridad de operaciones en Java

Al igual que las matemáticas, Java tiene prioridad sobre las operaciones. La siguiente tabla muestra la prioridad (de mayor a menor) de las operaciones que consideramos.

Ejemplos útiles de uso

Determinar la paridad de un número

Encontrar el elemento máximo en una matriz

Para encontrar el elemento mínimo, simplemente cambie el signo de comparación en el lugar correcto.