Qu'est-ce booléen retour signifie?

Question

Sur CodeReview j'ai posté un travail de morceau de code et a demandé des conseils pour l'améliorer. Celui que j'ai eu a été d'utiliser un booléen pour vérifier si une liste de tableaux avaient un même nombre d'indices (qui a été nécessaire). C'était le code qui a été proposé:

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

Comme je l'ai déjà pesté utilisateur particulier pour beaucoup de l'aide, je ai décidé qu'il était temps j'ai harcelé de la SORTE de la communauté! Je ne comprends pas vraiment comment cela fonctionne. La méthode est appelée et prend la taille de la liste de tableaux en paramètre (c'est à dire ArrayList a dix éléments, nombre = 10).

Je sais que d'un seul & exécute la comparaison du nombre et de la 1, mais je me suis perdu par la suite.

La façon dont je l'ai lu, c'est dire retourner true si l' number == 0 et 1 == 0. Je sais que le premier n'est pas vrai et ce dernier n'a évidemment pas de sens. Quelqu'un pourrait-il m'aider?

Edit: je devrais sans doute ajouter que le code fonctionne, dans le cas où certains se poseraient la question.

Answer 1

Gardez à l'esprit que le "&" est une opération au niveau du bit. Vous êtes probablement au courant de cela, mais il n'est pas totalement clair pour moi sur la base de la façon dont vous avez posé la question.

Cela étant dit, l'idée théorique est que vous avez un peu de type int, ce qui peut être exprimé en bits par une série de 1s et 0s. Par exemple:

...10110110

En binaire, parce que c'est la base 2, à chaque fois que le bit-à-bit version de le nombre se termine par 0, elle est de même, et quand elle se termine dans 1 il est impair.

Donc, faire un bit à bit et à 1 pour le ci-dessus est:

...10110110 & ...00000001

Bien sûr, c'est 0, donc on peut dire que l'entrée d'origine était de même.

Sinon, envisager un nombre impair. Par exemple, ajouter 1 à ce que nous avions ci-dessus. Alors

...10110111 & ...00000001

Est égal à 1, et n'est donc pas égal à zéro. Le tour est joué.

Answer 2

Vous pouvez déterminer le nombre est pair ou impair par le dernier bit de la représentation binaire:

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 deux nombres entiers est au niveau du bit ET de l'exploitant:

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

Donc, si (number & 1) == 0 est true, cela signifie number est même.

---

Supposons que, number == 6, alors:

6 -> 00000000000000000000000000000110 (even)

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

1 -> 00000000000000000000000000000001

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

0 -> 00000000000000000000000000000000

et lorsqu' number == 7:

7 -> 00000000000000000000000000000111 (odd)

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

1 -> 00000000000000000000000000000001

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

1 -> 00000000000000000000000000000001

Answer 3

& est le niveau du bit ET de l'opérateur. && est la logique ET de l'opérateur

En binaire, si les chiffres bit est réglé (j'.e), le nombre est impair.

En binaire, si les chiffres du bit est à zéro , le nombre est pair.

(number & 1) est un bit à bit ET de tester des chiffres peu.

Une autre façon de faire (et peut-être moins efficace, mais plus compréhensible) est l'aide de l'opérateur de modulo %:

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

    return (number % 2) == 0;
}

Answer 4

Cette expression signifie "l'entier représente un nombre pair".

Voici pourquoi: la représentation binaire de décimales 1 est 00000000001. Tous les nombres impairs fin en 1 en binaire (c'est facile à vérifier: supposons que le nombre binaire de représentation n'a pas de fin en 1; il est composé de non-zéro des puissances de deux, ce qui est toujours un nombre pair). Lorsque vous faites un binaire AND avec un nombre impair, le résultat est 1; lorsque vous faites un binaire AND avec un même nombre, le résultat est 0.

C'est la méthode préférée de décider pair/impair de retour à l'époque où les optimiseurs étaient pauvres, voire inexistante, et % opérateurs requis vingt fois le nombre de cycles réalisés par un & de l'opérateur. Ces jours, si vous ne number % 2 == 0, le compilateur est susceptible de générer du code qui s'exécute le plus rapidement (number & 1) == 0 .

Answer 5

Seul & moyen de bit-wise and de l'opérateur de ne pas la comparaison

Donc ce code vérifie si le premier bit (le moins important/le plus à droite) est définie ou pas, qui indique si le nombre est odd ou pas; parce que tous les nombres impairs se terminera avec 1 dans le bit le moins significatif par exemple, xxxxxxx1