Что означает это логическое значение (число & 1) == 0 "?

В CodeReview Я опубликовал рабочий код и попросил совета для его улучшения. Один, который я получил, - использовать логический метод, чтобы проверить, имеет ли ArrayList четное количество индексов (что было необходимо). Это был код, который был предложен:

private static boolean isEven(int number)
{
    return (number & 1) == 0;
}

Поскольку я уже приставал к этому конкретному пользователю для большой помощи, я решил, что время, когда я приставал к сообществу SO! Я действительно не понимаю, как это работает. Метод вызывается и принимает размер ArrayList в качестве параметра (то есть ArrayList имеет десять элементов, число = 10).

Я знаю, что в одном & выполняется сравнение как числа, так и 1, но после этого я потерялся.

Как я его читаю, он говорит return true, если number == 0 и 1 == 0. Я знаю, что первое не соответствует действительности, и последнее, очевидно, не имеет смысла. Может кто-нибудь помочь мне?

Изменить: я должен добавить, что код действительно работает, если кто-то задается вопросом.

Ответ 1

Имейте в виду, что "&" является поразрядной работой. Вы, вероятно, знаете об этом, но это не совсем ясно для меня, основываясь на том, как вы задавали вопрос.

Таким образом, теоретическая идея состоит в том, что у вас есть некоторый int, который может быть выражен в битах некоторой серией из 1s и 0s. Например:

...10110110

В двоичном формате, потому что это база 2, всякий раз, когда побитовая версия номера заканчивается на 0, она четна, а когда она заканчивается на 1, она нечетна.

Следовательно, выполнение поразрядного и с 1 для выше:

...10110110 & ...00000001

Конечно, это 0, поэтому вы можете сказать, что исходный вход был четным.

В качестве альтернативы рассмотрим нечетное число. Например, добавьте 1 к тому, что у нас было выше. Тогда

...10110111 & ...00000001

Является равным 1 и, следовательно, не равно нулю. Вуаля.

Ответ 2

Вы можете определить число либо четным, либо нечетным по последнему биту в его двоичном представлении:

1 -> 00000000000000000000000000000001 (odd)
2 -> 00000000000000000000000000000010 (even)
3 -> 00000000000000000000000000000011 (odd)
4 -> 00000000000000000000000000000100 (even)
5 -> 00000000000000000000000000000101 (odd)
6 -> 00000000000000000000000000000110 (even)
7 -> 00000000000000000000000000000111 (odd)
8 -> 00000000000000000000000000001000 (even)

& между двумя целыми числами является побитовым оператором AND:

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

Итак, если (number & 1) == 0 - true, это означает, что number четный.

Предположим, что number == 6, тогда:

6 -> 00000000000000000000000000000110 (even)

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

1 -> 00000000000000000000000000000001

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

0 -> 00000000000000000000000000000000

и когда number == 7:

7 -> 00000000000000000000000000000111 (odd)

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

1 -> 00000000000000000000000000000001

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

1 -> 00000000000000000000000000000001

Ответ 3

& - побитовый оператор И. && является логическим оператором AND

В двоичном формате, если бит бит установлен (то есть один), число нечетно.

В двоичном формате, если бит цифр равен нулю, число равно.

(number & 1) является поразрядным И-битом бит бит.

Другой способ сделать это (и, возможно, менее эффективный, но более понятный) - использовать оператор модуля %:

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

    return (number % 2) == 0;
}

Ответ 4

Это выражение означает, что "целое число представляет четное число".

Вот почему: двоичное представление десятичного 1 равно 00000000001. Все нечетные числа заканчиваются на 1 в двоичном формате (это легко проверить: предположим, что двоичное представление числа не заканчивается на 1, а затем оно состоит из ненулевых степеней двух, что всегда является четным числом). Когда вы выполняете двоичный AND с нечетным числом, результат 1; когда вы выполняете двоичный AND с четным числом, результат 0.

Это был предпочтительный метод решения нечетных/четных в то время, когда оптимизаторы были плохими до несуществующих, а операторы % требовали в два раза больше циклов, принимаемых оператором &. В наши дни, если вы выполняете number % 2 == 0, компилятор, скорее всего, сгенерирует код, который выполняется так же быстро, как (number & 1) == 0.

Ответ 5

Единый & означает бит-мудрый and оператор не сравнение

Таким образом, этот код проверяет, установлен ли первый bit (наименее значимый/самый правый), который указывает, является ли число odd или нет; потому что все нечетные числа заканчиваются на 1 в наименее значимом бите, например. xxxxxxx1

Ответ 6

& - побитовая операция AND.

Для числа = 8:

В результате (8 & 1) == 0. Это относится ко всем четным числам, так как они кратные 2, а первая двоичная цифра справа всегда равна 0. 1 имеет двоичное значение 1 с ведущими 0, поэтому, когда мы AND с четным числом, мы 'осталось с 0.

Ответ 7

Оператор & в Java является побитовым и оператором. В принципе, (number & 1) выполняет побитовое и между number и 1. Результат будет либо 0, либо 1, в зависимости от того, является ли он четным или нечетным. Затем результат сравнивается с 0, чтобы определить, даже ли это.

Здесь страница, описывающая побитовые операции.

Ответ 8

Он выполняет двоичный и против 1, который возвращает 0, если младший значащий бит не установлен

для вашего примера

00001010 (10)

00000001 (1)

===========

00000000 (0)

Ответ 9

Это логическая концепция дизайна побитовая и (И) операционная система.

return (2 и 1); означает преобразование значения в побитовые числа и компарацию функции (AND) и возвращает значение.

Предпочитаете эту ссылку http://www.roseindia.net/java/master-java/java-bitwise-and.shtml