¿Qué significa este booleano "(número & 1) == 0"?

En CodeReview publiqué un fragmento de código funcional y pedí sugerencias para mejorarlo. Uno que obtuve fue usar un método booleano para verificar si un ArrayList tenía un número par de índices (que 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 para que me ayude, ¡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é que un solo hace &la comparación del número y el 1, pero me perdí después de eso.

De la forma en que lo leo, dice return true si number == 0y 1 == 0. Sé que lo primero no es cierto y lo segundo, obviamente, no tiene sentido. ¿Alguien podría ayudarme?

Editar: probablemente debería agregar que el código funciona, en caso de que alguien se lo pregunte.

Tenga en cuenta que "&" es una operación bit a bit. Probablemente sea consciente de esto, pero no me queda del todo claro por la forma en que planteó la pregunta.

Dicho esto, la idea teórica es que tienes algo de int, que se puede expresar en bits por alguna serie de unos y ceros. Por ejemplo:

...10110110

En binario, debido a que es base 2, siempre que la versión bit a bit del número termina en 0, es par, y cuando termina en 1 es impar.

Por lo tanto, hacer un bit a bit & 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. Luego

...10110111 & ...00000001

Es igual a 1 y, por tanto, no es igual a cero. Voila.

Puede determinar que el número es par o impar por 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 el operador AND bit a bit:

0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1

Entonces, si (number & 1) == 0es true, esto significa que numberes par.

Supongamos que number == 6, entonces:

6 -> 00000000000000000000000000000110 (even)

     &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

1 -> 00000000000000000000000000000001

-------------------------------------

0 -> 00000000000000000000000000000000

y cuando number == 7:

7 -> 00000000000000000000000000000111 (odd)

     &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

1 -> 00000000000000000000000000000001

-------------------------------------

1 -> 00000000000000000000000000000001

&es el operador AND bit a bit. &&es el operador lógico AND

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 del bit de dígitos.

Otra forma de hacer esto (y posiblemente menos eficiente pero más comprensible) es usando el operador de módulo %:

private static boolean isEven(int number)
{
    if (number < 0)
       throw new ArgumentOutOfRangeException();

    return (number % 2) == 0;
}

Esta expresión significa "el número entero representa un número par".

Aquí está la razón: la representación binaria de decimal 1es 00000000001. Todos los números impares terminan en 1binario (esto es fácil de verificar: suponga que la representación binaria del número no termina en 1; entonces se compone de potencias de dos distintas de cero, que siempre es un número par). Cuando haces un binario ANDcon un número impar, el resultado es 1; cuando haces un binario ANDcon un número par, el resultado es 0.

Este solía ser el método preferido para decidir los pares / impares en el momento en que los optimizadores eran deficientes o inexistentes, y los %operadores requerían veinte veces el número de ciclos realizados por un &operador. En estos días, si lo hace number % 2 == 0, es probable que el compilador genere código que se ejecute tan rápido como lo (number & 1) == 0hace.

Solo &significa andoperador bit a bit , no comparación

Entonces, este código verifica si el primero bit(el menos significativo / el más correcto) está configurado o no, lo que indica si el número lo es oddo no; porque todos los números impares terminarán con 1el bit menos significativo, por ejemploxxxxxxx1

&es una ANDoperación bit a bit .

Para número = 8:

  1000
  0001
& ----
  0000

El resultado es ese (8 & 1) == 0. Este es el caso de todos los números pares, ya que son múltiplos de 2 y el primer dígito binario de la derecha siempre es 0. 1 tiene un valor binario de 1 con ceros a la ANDizquierda , así que cuando lo ponemos con un número par nos quedamos con 0.

El &operador en Java es el operador and bit a bit. Básicamente, (number & 1)realiza un bit a bit y entre numbery1 . 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 contra 1, que devuelve 0 si no se establece el bit menos significativo

por tu ejemplo

00001010 (10)

00000001 (1)

===========

00000000 (0)

Este es el concepto de diseño lógico bit a bit y (AND) operater.

return (2 y 1); significa: convierte el valor en números bit a bit y compara la función (Y) y devuelve el valor.

Prefiera este enlace http://www.roseindia.net/java/master-java/java-bitwise-and.shtml