Que fait l'opérateur ^ en Java?
Quelle fonction l'opérateur ^ (caret) remplit-il en Java?
Quand j'essaye ceci:
int a = 5^n;
...ça me donne:
pour n = 5, renvoie 0
pour n = 4, renvoie 1
pour n = 6, retourne 3
... donc je suppose qu'il ne réalise pas d'exponentiation. Mais qu'est-ce que c'est alors?
L'opérateur ^ en Java
^ in Java est l'opérateur exclusif-ou ("xor").
Prenons 5^6 comme exemple:
(decimal) (binary)
5 = 101
6 = 110
------------------ xor
3 = 011
C’est la table de vérité pour bitwise ( JLS 15.22.1 ) et logique ( JLS 15.22.2 ) xor:
^ | 0 1 ^ | F T
--+----- --+-----
0 | 0 1 F | F T
1 | 1 0 T | T F
Plus simplement, vous pouvez aussi considérer xor comme "ceci ou cela, mais pas les deux !".
Voir également
Exponentiation en Java
En ce qui concerne l'exponentiation entière, malheureusement, Java ne dispose pas d'un tel opérateur. Vous pouvez utiliser double Math.pow(double, double) (transtyper le résultat en int si nécessaire).
Vous pouvez également utiliser le truc traditionnel de transfert de bits pour calculer des puissances de deux. Autrement dit, (1L << k) est égal à deux k - ème puissance de k=0..63.
Voir également
Fusionner la note : cette réponse a été fusionnée à partir d'une autre question dans laquelle l'intention était d'utiliser l'exponentiation pour convertir une chaîne
"8675309"àintsans utiliserInteger.parseIntcomme exercice de programmation (^désigne désormais une exponentiation). L'intention du PO était de calculer8*10^6 + 6*10^5 + 7*10^4 + 5*10^3 + 3*10^2 + 0*10^1 + 9*10^0 = 8675309; La partie suivante de cette réponse indique que l’exponentiation n’est pas nécessaire pour cette tâche.
Schéma de Horner
Pour répondre à vos besoins spécifiques , vous n'avez pas besoin de calculer différentes puissances de 10. Vous pouvez utiliser ce que l'on appelle le schéma de Horner , qui n'est pas seulement simple mais aussi efficace.
Puisque vous faites cela à titre personnel, je ne donnerai pas le code Java, mais voici l’idée principale:
8675309 = 8*10^6 + 6*10^5 + 7*10^4 + 5*10^3 + 3*10^2 + 0*10^1 + 9*10^0
= (((((8*10 + 6)*10 + 7)*10 + 5)*10 + 3)*10 + 0)*10 + 9
Cela peut paraître compliqué au début, mais ce n’est vraiment pas le cas. En gros, vous lisez les chiffres de gauche à droite et vous multipliez votre résultat jusqu'à présent par 10 avant d'ajouter le chiffre suivant.
Sous forme de tableau:
step result digit result*10+digit
1 init=0 8 8
2 8 6 86
3 86 7 867
4 867 5 8675
5 8675 3 86753
6 86753 0 867530
7 867530 9 8675309=final
Comme de nombreuses personnes l’ont déjà fait remarquer, c’est l’opérateur XOR . De nombreuses personnes ont également déjà fait remarquer que si vous voulez une exponentiation, vous devez utiliser Math.pow .
Mais je pense qu'il est également utile de noter que ^ fait partie de la famille d'opérateurs appelés collectivement opérateurs bit à bit:
Operator Name Example Result Description
a & b and 3 & 5 1 1 if both bits are 1.
a | b or 3 | 5 7 1 if either bit is 1.
a ^ b xor 3 ^ 5 6 1 if both bits are different.
~a not ~3 -4 Inverts the bits.
n << p left shift 3 << 2 12 Shifts the bits of n left p positions. Zero bits are shifted into the low-order positions.
n >> p right shift 5 >> 2 1 Shifts the bits of n right p positions. If n is a 2's complement signed number, the sign bit is shifted into the high-order positions.
n >>> p right shift -4 >>> 28 15 Shifts the bits of n right p positions. Zeros are shifted into the high-order positions.
De ici .
Ces opérateurs peuvent s'avérer utiles lorsque vous devez lire et écrire sur des nombres entiers, où les bits individuels doivent être interprétés comme des indicateurs, ou lorsqu'une plage spécifique de bits d'un nombre entier a une signification particulière et que vous souhaitez extraire uniquement ceux-ci. Vous pouvez faire beaucoup de programmation au quotidien sans avoir à utiliser ces opérateurs, mais si vous devez travailler avec des données au niveau des bits, une bonne connaissance de ces opérateurs est inestimable.
Il s’agit d’un bitor XOR, Java n’a pas d’opérateur d’exponentiation, vous devez utiliser Math.pow() à la place.
C'est l'opérateur XOR bitwise.
Comme d’autres l’ont dit, c’est un bit XOR. Si vous voulez augmenter un nombre à une puissance donnée, utilisez Math.pow(a , b) , où a est un nombre et b est le pouvoir.
Beaucoup de gens ont déjà expliqué en quoi consistait ce logiciel et comment l'utiliser, mais en plus de l'évidence, vous pouvez utiliser cet opérateur pour réaliser de nombreuses astuces de programmation telles que
- XORing de tous les éléments d'un tableau booléen vous dira si le tableau a un nombre impair de vrais éléments
- Si vous avez un tableau avec tous les nombres répétés un nombre pair de fois, sauf un qui répète un nombre impair de fois, vous pouvez le trouver en XORing tous les éléments.
- Échange de valeurs sans utiliser de variable temporaire
- Recherche du nombre manquant dans la plage 1 à n
- Validation de base des données envoyées sur le réseau.
Beaucoup de ces astuces peuvent être réalisées à l'aide d'opérateurs peu intelligents, un sujet intéressant à explorer.
Règle d'opérateur XOR =>
0 ^ 0 = 0
1 ^ 1 = 0
0 ^ 1 = 1
1 ^ 0 = 1
Représentation binaire de 4, 5 et 6:
4 = 1 0 0
5 = 1 0 1
6 = 1 1 0
maintenant, effectuez l'opération XOR sur 5 et 4:
5 ^ 4 => 1 0 1 (5)
1 0 0 (4)
----------
0 0 1 => 1
De même,
5 ^ 5 => 1 0 1 (5)
1 0 1 (5)
------------
0 0 0 => (0)
5 ^ 6 => 1 0 1 (5)
1 1 0 (6)
-----------
0 1 1 => 3
C'est l'opérateur Bitwise xor en Java qui obtient 1 pour une valeur de bit différente (c'est-à-dire 1 ^ 0 = 1) et 0 pour une valeur de bit identique (c'est-à-dire 0 ^ 0 = 0) lorsqu'un nombre est écrit sous forme binaire.
ex: -
Pour utiliser votre exemple:
La représentation binaire de 5 est 0101 . La représentation binaire de 4 est 0100.
Un moyen simple de définir Bitwise XOR est de dire que le résultat a un 1 à chaque endroit où les deux nombres entrés diffèrent.
0101 ^ 0100 = 0001 (5 ^ 4 = 1).
utilisez plutôt Math.pow:
http://Java.Sun.com/j2se/1.4.2/docs/api/Java/lang/Math.html#pow%28double,%20double%29
Comme déjà indiqué dans les autres réponses, il s'agit de l'opérateur "exclusif ou" (XOR) . Pour plus d'informations sur les opérateurs de bits en Java, voir: http://Java.Sun.com/docs/books/tutorial/Java/nutsandbolts/op3.html
Le lien d'AraK pointe vers la définition de ou exclusif, qui explique le fonctionnement de cette fonction pour deux valeurs booléennes.
L'information manquante est la façon dont cela s'applique à deux entiers (ou valeurs de type entier). Le paramètre binaire exclusif-ou est appliqué à des paires de chiffres binaires correspondants en deux chiffres, et les résultats sont ré-assemblés en un résultat entier.
Pour utiliser votre exemple:
- La représentation binaire de 5 est 0101.
- La représentation binaire de 4 est 0100.
Un moyen simple de définir au niveau du bit XOR est de dire que le résultat a un 1 à chaque endroit où les deux nombres entrés diffèrent.
Avec 4 et 5, la seule différence est à la dernière place; alors
0101 ^ 0100 = 0001 (5 ^ 4 = 1).
C'est parce que vous utilisez l'opérateur xor.
En Java, ou à peu près n'importe quel autre langage, ^ est bitwise xor, Donc bien sûr,
10 ^ 1 = 11 . plus d'informations sur les opérateurs au niveau des bits
Il est intéressant de voir comment Java et C # n’ont pas d’opérateur électrique.
C'est l'opérateur xor au niveau du bit en Java qui donne 1 pour une valeur différente (c'est-à-dire 1 ^ 0 = 1) et 0 pour une même valeur (soit 0 ^ 0 = 0).
C'est l'opérateur XOR. C'est utilisé pour faire des opérations sur les nombres. Son comportement est tel que lorsque vous effectuez une opération xor sur les mêmes bits et que vous indiquez 0 XOR 0/1 XOR 1, le résultat est 0. Toutefois, si l'un des bits est différent, le résultat est 1.. Alors, quand vous avez fait 5 ^ 3, alors vous pouvez regarder ces nombres 5, 6 sous leur forme binaire et ainsi l'expression devient (101) XOR (110), ce qui donne le résultat (011) dont la représentation décimale est 3.
^ est binaire (comme en base 2) xor, pas une exponentiation (non disponible en tant qu'opérateur Java). Pour une exponentiation, voir Java.lang.Math.pow ().
Règle d'opérateur XOR
0 ^ 0 = 0
1 ^ 1 = 0
0 ^ 1 = 1
1 ^ 0 = 1
Opérateur au niveau du bit travaille sur les bits et effectue une opération bit par bit Supposons si a = 60 et b = 13; maintenant au format binaire, ils seront comme suit -
a = 0011 1100
b = 0000 1101
a^b ==> 0011 1100 (a)
0000 1101 (b)
------------- XOR
0011 0001 => 49
(a ^ b) will give 49 which is 0011 0001
Dans d'autres langages comme Python, vous pouvez faire 10 ** 2 = 100, essayez-le.