java - example - ¿Qué significa este booleano "(number & 1)== 0"?
import arraylist java (9)
Único & significa bit-wise and operador no comparación
Entonces, este código verifica si el primer bit (menos significativo / más correcto) está configurado o no, lo que indica si el número es odd o no; porque todos los números impares terminarán con 1 en el bit menos significativo, por ejemplo xxxxxxx1
En CodeReview publiqué un código de trabajo y le pedí consejos para mejorarlo. Una que obtuve fue usar un método booleano para verificar si una lista de matrices tenía un número par de índices (lo cual era obligatorio). Este fue el código que se sugirió:
private static boolean isEven(int number)
{
return (number & 1) == 0;
}
Como ya he molestado a ese usuario en particular por mucha ayuda, ¡he decidido que es hora de molestar a la comunidad SO! Realmente no entiendo cómo funciona esto. Se llama al método y toma el tamaño de ArrayList como parámetro (es decir, ArrayList tiene diez elementos, número = 10).
Sé uno solo & ejecuta la comparación de ambos número y 1, pero me perdí después de eso.
La forma en que lo leí, está diciendo return true if number == 0 y 1 == 0 . Sé que lo primero no es verdad y lo último obviamente no tiene sentido. ¿Alguien podría ayudarme?
Editar: probablemente debería agregar que el código funciona, en caso de que alguien se esté preguntando.
El operador & en Java es el operador bit a bit. Básicamente, (number & 1) realiza un bitwise-y entre number y 1 . El resultado es 0 o 1, dependiendo de si es par o impar. Luego, el resultado se compara con 0 para determinar si es par.
Aquí hay una página que describe las operaciones bit a bit .
Está realizando un binario y en contra de 1, que devuelve 0 si no se establece el bit menos significativo
para tu ejemplo
00001010 (10)
00000001 (1)
===========
00000000 (0)
Esta expresión significa "el número entero representa un número par".
Esta es la razón por la cual: la representación binaria del decimal 1 es 00000000001 . Todos los números impares terminan en un 1 en binario (esto es fácil de verificar: supongamos que la representación binaria del número no termina en 1 ; luego está compuesta por potencias de dos distintas de cero, que siempre es un número par). Cuando haces un AND binario con un número impar, el resultado es 1 ; cuando haces un AND binario con un número par, el resultado es 0 .
Este solía ser el método preferido para decidir el retorno impar / par en el momento en que los optimizadores eran deficientes o inexistentes, y el % operadores requerían veinte veces el número de ciclos tomados por un operador & . En estos días, si haces el number % 2 == 0 , es probable que el compilador genere código que se ejecute tan rápido como (number & 1) == 0 hace.
Este es el operador de bit lógico y (Y) del concepto de diseño lógico.
regreso (2 y 1); significa: convierte el valor a números de bits y combina la función (Y) y devuelve el valor.
Prefiero este enlace http://www.roseindia.net/java/master-java/java-bitwise-and.shtml
Puede determinar si el número es par o impar en el último bit en su representación binaria:
1 -> 00000000000000000000000000000001 (odd)
2 -> 00000000000000000000000000000010 (even)
3 -> 00000000000000000000000000000011 (odd)
4 -> 00000000000000000000000000000100 (even)
5 -> 00000000000000000000000000000101 (odd)
6 -> 00000000000000000000000000000110 (even)
7 -> 00000000000000000000000000000111 (odd)
8 -> 00000000000000000000000000001000 (even)
& entre dos enteros es operador AND bit a bit:
0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1
Entonces, si (number & 1) == 0 es true , esto significa que el number es par.
Supongamos que el number == 6 , entonces:
6 -> 00000000000000000000000000000110 (even)
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1 -> 00000000000000000000000000000001
-------------------------------------
0 -> 00000000000000000000000000000000
y cuando number == 7 :
7 -> 00000000000000000000000000000111 (odd)
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1 -> 00000000000000000000000000000001
-------------------------------------
1 -> 00000000000000000000000000000001
Tenga en cuenta que "&" es una operación bit a bit. Probablemente estés al tanto de esto, pero no está del todo claro para mí en base a la forma en que planteaste la pregunta.
Dicho esto, la idea teórica es que tienes algunos int, que se pueden expresar en bits por algunas series de 1s y 0s. Por ejemplo:
...10110110
En binario, porque es la base 2, siempre que la versión bit a bit del número termine en 0, es par, y cuando termina en 1 es impar.
Por lo tanto, hacer un bitwise y con 1 para lo anterior es:
...10110110 & ...00000001
Por supuesto, esto es 0, por lo que puede decir que la entrada original fue pareja.
Alternativamente, considere un número impar. Por ejemplo, agregue 1 a lo que teníamos arriba. Entonces
...10110111 & ...00000001
Es igual a 1, y por lo tanto, no es igual a cero. Voila.
& es el operador AND bit a bit. && es el operador AND lógico
En binario, si el bit de dígitos está establecido (es decir, uno), el número es impar.
En binario, si el bit de dígitos es cero, el número es par.
(number & 1) es una prueba AND bit a bit de los dígitos.
Otra forma de hacer esto (y posiblemente menos eficiente pero más comprensible) es usar el operador de módulo % :
private static boolean isEven(int number)
{
if (number < 0)
throw new ArgumentOutOfRangeException();
return (number % 2) == 0;
}
& es una operación AND bit.
Para number = 8:
1000
0001
& ----
0000
El resultado es que (8 & 1) == 0 . Este es el caso para todos los números pares, ya que son múltiplos de 2 y el primer dígito binario de la derecha es siempre 0. 1 tiene un valor binario de 1 con los 0 iniciales, por lo tanto, cuando lo AND con un número par estamos izquierda con 0.