Intereting Posts

NoSQL – MongoDB vs CouchDB Comment obtenir C # .Net Assembly par son nom? Comment append une icône d’application dans les projets phonegap? Comment dois-je traiter les mutex dans les types mobiles en C ++? Fichiers statiques Django 404 Mono https webrequest échoue avec “L’authentification ou le déchiffrement a échoué” Ajouter un mappage MIME dans web.config pour IIS Express Puis-je restaurer une seule table depuis un fichier mysql mysqlump complet? Rails 4 scope par défaut Code équivalent au mot clé ‘let’ dans les appels de méthode d’extension LINQ chaînés Comment utiliser la barre latérale avec le clavier dans Sublime Text 2 et 3? xUnit: Assert deux List sont égaux? NodeJS / Express: qu’est-ce que “app.use”? Modèles jQuery recommandés pour 2012? Erreur de génération d’équipe: le chemin d’access… est déjà associé à l’espace de travail

Que signifie ce booléen «(nombre & 1) == 0»?

Sur CodeReview, j’ai posté un code de travail et demandé des conseils pour l’améliorer. L’une d’elles était d’utiliser une méthode booléenne pour vérifier si un ArrayList avait un nombre pair d’indices (ce qui était nécessaire). C’était le code qui a été suggéré:

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

Comme j’ai déjà harcelé cet utilisateur en particulier, j’ai décidé qu’il était temps de harceler la communauté SO! Je ne comprends pas vraiment comment cela fonctionne. La méthode est appelée et prend la taille de ArrayList en tant que paramètre (par exemple, ArrayList a dix éléments, nombre = 10).

Je connais un seul & exécute la comparaison des deux numéros et 1, mais je me suis perdu après ça.

La façon dont je le lis est de dire retourner true si number == 0 et 1 == 0 . Je sais que le premier n’est pas vrai et que le dernier n’a évidemment aucun sens. Quelqu’un pourrait-il m’aider?

Edit: Je devrais probablement append que le code fonctionne, au cas où quelqu’un se demanderait.

Gardez à l’esprit que “&” est une opération au niveau du bit. Vous êtes probablement au courant de cela, mais ce n’est pas tout à fait clair pour moi en fonction de la manière dont vous avez posé la question.

Cela étant dit, l’idée théorique est que vous avez un int, qui peut être exprimé en bits par des séries de 1 et de 0. Par exemple:

 ...10110110

En binary, parce que c’est la base 2, chaque fois que la version binary du nombre se termine par 0, elle est paire et quand elle se termine par 1, elle est impaire.

Par conséquent, faire un bit & avec 1 pour le précédent est:

 ...10110110 & ...00000001

Bien sûr, cela vaut 0, vous pouvez donc dire que l’entrée originale était paire.

Vous pouvez également envisager un nombre impair. Par exemple, ajoutez 1 à ce que nous avions ci-dessus. alors

 ...10110111 & ...00000001

Est égal à 1 et n’est donc pas égal à zéro. Voila.

Vous pouvez déterminer que le nombre est pair ou impair par le dernier bit de sa représentation binary:

 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 l’opérateur binary ET:

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

Donc, si (number & 1) == 0 est true , cela signifie que le number est pair.

Supposons que ce number == 6 , alors:

 6 -> 00000000000000000000000000000110 (even) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 1 -> 00000000000000000000000000000001 ------------------------------------- 0 -> 00000000000000000000000000000000

et quand number == 7 :

 7 -> 00000000000000000000000000000111 (odd) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 1 -> 00000000000000000000000000000001 ------------------------------------- 1 -> 00000000000000000000000000000001

& est l’opérateur bitwise AND. && est l’opérateur logique AND

En binary, si le bit de chiffres est défini (c.-à-d. Un), le nombre est impair.

En binary, si le bit de chiffres est zéro, le nombre est pair.

(number & 1) est un test ET bit par bit du bit de chiffres.

Une autre façon de le faire (et peut-être moins efficace mais plus compréhensible) consiste à utiliser l’opérateur de module % :

 private static boolean isEven(int number) { if (number < 0) throw new ArgumentOutOfRangeException(); return (number % 2) == 0; }

Cette expression signifie que “l’entier représente un nombre pair”.

Voici la raison pour laquelle: la représentation binary du nombre décimal 1 est 00000000001 . Tous les nombres impairs se terminent par un 1 en binary (cela est facile à vérifier: supposons que la représentation binary du nombre ne se termine pas par 1 , alors elle est composée de deux puissances non nulles, ce qui est toujours un nombre pair). Lorsque vous faites un AND binary avec un nombre impair, le résultat est 1 ; Lorsque vous faites un AND binary avec un nombre pair, le résultat est 0 .

Auparavant, c’était la méthode préférée pour déterminer les rapports impair / pair lorsque les optimiseurs étaient faibles ou inexistants, et les opérateurs % exigeaient vingt fois le nombre de cycles pris par un opérateur. Ces jours-ci, si vous faites le number % 2 == 0 , le compilateur est susceptible de générer du code qui s’exécute aussi rapidement que (number & 1) == 0 .

Single & signifie bit-wise and opérateur pas de comparaison

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

& est une opération AND bit à bit.

Pour numéro = 8:

  1000 0001 & ---- 0000

Le résultat est que (8 & 1) == 0 . C’est le cas pour tous les nombres pairs, étant donné qu’ils sont des multiples de 2 et que le premier chiffre binary de droite est toujours 0. 1 a une valeur binary de 1 avec des 0, alors quand nous AND laissé avec 0.

L’opérateur & en Java est l’opérateur et le bit-bit. Fondamentalement, (number & 1) effectue un number et entre un number et 1 . Le résultat est 0 ou 1, selon qu’il est pair ou impair. Ensuite, le résultat est comparé à 0 pour déterminer s’il est pair.

Voici une page décrivant les opérations binarys .

Il effectue un binary et contre 1, qui renvoie 0 si le bit le moins significatif n’est pas défini

pour ton exemple

00001010 (10)

00000001 (1)

===========

00000000 (0)

C’est le concept de conception logique bitwise & (AND) operater.

retour (2 & 1); signifie – convertit la valeur en nombres binarys et comapre la fonction (AND) et renvoie la valeur.

Préférer ce lien http://www.roseindia.net/java/master-java/java-bitwise-and.shtml