¿Cómo funcionan los operadores de turno en Java?

Intento entender a los operadores de turno y no pude obtener mucho. Cuando intenté ejecutar el código siguiente

System.out.println(Integer.toBinaryString(2 << 11)); System.out.println(Integer.toBinaryString(2 << 22)); System.out.println(Integer.toBinaryString(2 << 33)); System.out.println(Integer.toBinaryString(2 << 44)); System.out.println(Integer.toBinaryString(2 << 55)); 

Obtengo el siguiente

 1000000000000 100000000000000000000000 100 10000000000000 1000000000000000000000000 

¿Podría alguien explicar por favor?

 System.out.println(Integer.toBinaryString(2 < < 11)); 

Cambia el binario 2 ( 10 ) por 11 veces a la izquierda. Por lo tanto: 1000000000000

 System.out.println(Integer.toBinaryString(2 < < 22)); 

Cambia el binario 2 ( 10 ) por 22 veces hacia la izquierda. Por lo tanto: 100000000000000000000000

 System.out.println(Integer.toBinaryString(2 < < 33)); 

Ahora, int es de 4 bytes, por lo tanto, 32 bits. Entonces cuando cambias por 33, es equivalente a cambiar por 1. Por lo tanto: 100

2 del sistema de numeración decimal en binario es el siguiente

 10 

ahora si lo haces

 2 < < 11 

sería, 11 ceros estarían acolchados en el lado derecho

 1000000000000 

El operador de desplazamiento a la izquierda con signo "< <" desplaza un patrón de bits hacia la izquierda, y el operador de cambio a la derecha con signo ">>" desplaza un patrón de bits hacia la derecha. El patrón de bits está dado por el operando de la izquierda y el número de posiciones para cambiar por el operando de la mano derecha. El operador de desplazamiento a la derecha sin signo ">>>" cambia el cero a la posición más a la izquierda, mientras que la posición a la izquierda después de ">>" depende de la extensión del signo [..]

resultados de desplazamiento a la izquierda en la multiplicación por 2 (* 2) en términos o aritmética


Por ejemplo

2 en 10 binarios, si haces < <1 que sería 100 que es 4

4 en 100 binarios, si haces < <1 que sería 1000 que es 8


Ver también

  • absoluto-principiantes-guía-a-bit-shifting

Los cambios a la derecha y a la izquierda funcionan de la misma manera aquí. Cómo funciona el desplazamiento a la derecha; El desplazamiento a la derecha: el operador de desplazamiento a la derecha, >>, desplaza todos los bits en un valor a la derecha un número específico de veces. Su forma general:

 value >> num 

Aquí, num especifica el número de posiciones para desplazar hacia la derecha el valor en valor. Es decir, >> mueve todos los bits en el valor especificado a la derecha el número de posiciones de bit especificado por num. El siguiente fragmento de código desplaza el valor 32 a la derecha en dos posiciones, lo que da como resultado que se establezca en 8:

 int a = 32; a = a >> 2; // a now contains 8 

Cuando un valor tiene bits que están “desplazados”, esos bits se pierden. Por ejemplo, el siguiente fragmento de código desplaza el valor 35 a las dos posiciones correctas, lo que hace que se pierdan los dos bits de orden inferior, lo que da como resultado un valor de 8.

 int a = 35; a = a >> 2; // a still contains 8 

Observando la misma operación en binario muestra más claramente cómo sucede esto:

 00100011 35 >> 2 00001000 8 

Cada vez que cambia un valor a la derecha, divide ese valor por dos y descarta cualquier rest. Puede aprovechar esto para la división de enteros de alto rendimiento en 2. Por supuesto, debe estar seguro de que no está desplazando ningún bit del extremo derecho. Cuando se está desplazando hacia la derecha, los bits superiores (más a la izquierda) expuestos por el desplazamiento a la derecha se rellenan con los contenidos anteriores del bit superior. Esto se denomina extensión de signo y sirve para conservar el signo de los números negativos cuando los desplaza hacia la derecha. Por ejemplo, –8 >> 1 es –4 , que, en binario, es

 11111000 –8 >>1 11111100 –4 

Es interesante observar que si se desplaza -1 a la derecha, el resultado siempre permanece -1, ya que la extensión de signo sigue trayendo más en los bits de orden superior. Algunas veces no es deseable firmar-extender valores cuando los está moviendo a la derecha. Por ejemplo, el siguiente progtwig convierte un valor de byte a su representación de cadena hexadecimal. Observe que el valor desplazado está enmascarado por ANDing con 0x0f para descartar cualquier bit de signo extendido para que el valor se pueda utilizar como un índice en la matriz de caracteres hexadecimales.

 // Masking sign extension. class HexByte { static public void main(String args[]) { char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; byte b = (byte) 0xf1; System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]); } } 

Aquí está el resultado de este progtwig:

 b = 0xf1 

Creo que esto podría ayudar:

  System.out.println(Integer.toBinaryString(2 < < 0)); System.out.println(Integer.toBinaryString(2 << 1)); System.out.println(Integer.toBinaryString(2 << 2)); System.out.println(Integer.toBinaryString(2 << 3)); System.out.println(Integer.toBinaryString(2 << 4)); System.out.println(Integer.toBinaryString(2 << 5)); 

Resultado

  10 100 1000 10000 100000 1000000 

Editado:

Debe leer esto (how-do-the-bitwise-shift-operators-work)

Creo que sería lo siguiente, por ejemplo:

  • Firmado el turno de la izquierda

[2 < < 1] es => [10 (binario de 2) agregue 1 cero al final de la secuencia binaria] Por lo tanto 10 será 100 que se convierte en 4.

El cambio a la izquierda firmado usa la multiplicación … Entonces esto también podría calcularse como 2 * (2 ^ 1) = 4. Otro ejemplo [ 2 < < 11] = 2 * (2 ^ 11) = 4096

  • Cambio a la derecha firmado

[4 >> 1] es => [100 (binario de 4) elimina 1 cero al final de la secuencia binaria] Por lo tanto 100 será 10 que se convierte en 2.

El desplazamiento a la derecha con signo utiliza la división … Así que esto también podría calcularse como 4 / (2 ^ 1) = 2 Otro ejemplo [ 4096 >> 11] = 4096 / (2 ^ 11) = 2

Cambiará los bits rellenando esos tantos.

Por ejemplo,

  • El 10 binario que es el dígito 2 desplazamiento a la izquierda por 2 es 1000 que es el dígito 8
  • el 10 binario que es el dígito 2 desplazamiento a la izquierda por 3 es 10000 que es el dígito 16

El cambio se puede implementar con tipos de datos (char, int y long int). El flotador y el doble de datos no se pueden cambiar.

 value= value >> steps // Right shift, signed data. value= value < < steps // Left shift, signed data. 

Giro a la izquierda firmado Lógicamente simple si 1 < < 11 tiende a 2048 y 2 << 11 dará 4096

En progtwigción java int a = 2 < < 11;

 // it will result in 4096 2< <11 = 2*(2^11) = 4096 

El uso típico de desplazar una variable y asignar de nuevo a la variable se puede reescribir con los operadores abreviados < < = , >> = , o >>> = , también conocidos en la especificación como Operadores de Asignación de Compuestos .

Por ejemplo,

 i >>= 2 

produce el mismo resultado que

 i = i >> 2