Что означает это логическое значение (число & 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:
1000
0001
& ----
0000
В результате (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
