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, renvoie 3

... donc je suppose que cela n'exécute pas l'exponentiation. Mais c'est quoi alors?

L'opérateur ^ en Java

^ en Java est l'opérateur exclusif ou ("xor").

Prenons 5^6comme exemple:

(decimal)    (binary)
     5     =  101
     6     =  110
------------------ xor
     3     =  011

Voici la table de vérité pour xor au niveau du bit ( JLS 15.22.1 ) et logique ( JLS 15.22.2 ):

^ | 0 1      ^ | F T
--+-----     --+-----
0 | 0 1      F | F T
1 | 1 0      T | T F

Plus simplement, vous pouvez également considérer xor comme "ceci ou cela, mais pas les deux !".

Voir également

• Wikipédia: exclusif ou

Exponentiation en Java

Quant à l'exponentiation d'entier, malheureusement Java n'a pas un tel opérateur. Vous pouvez utiliser double Math.pow(double, double)(lancer le résultat intsi nécessaire).

Vous pouvez également utiliser l'astuce traditionnelle de décalage de bits pour calculer certains pouvoirs de deux. Autrement dit, (1L << k)est deux à la puissance k-e pour k=0..63.

Voir également

• Wikipédia: changement arithmétique

Note de fusion : cette réponse a été fusionnée à partir d'une autre question où l'intention était d'utiliser l'exponentiation pour convertir une chaîne"8675309"enintsans l'utiliserInteger.parseIntcomme un exercice de programmation (^dénote désormais l'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 explique que l'exponentiation n'est pas nécessaire pour cette tâche.

Le schéma de Horner

Pour répondre à vos besoins spécifiques , vous n'avez en fait pas besoin de calculer différentes puissances de 10. Vous pouvez utiliser ce que l'on appelle le schéma de Horner , qui est non seulement simple mais aussi efficace.

Puisque vous faites cela comme un exercice 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 sembler compliqué au début, mais ce n'est vraiment pas le cas. Vous lisez fondamentalement 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 beaucoup de personnes l'ont déjà souligné, c'est l' opérateur XOR . De nombreuses personnes ont également souligné que si vous souhaitez une exponentiation, vous devez utiliser Math.pow .

Mais je pense qu'il est également utile de noter que ce ^n'est que l'un d'une famille d'opérateurs appelés collectivement opérateurs au niveau du 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.

D' ici .

Ces opérateurs peuvent être utiles lorsque vous devez lire et écrire dans des entiers où les bits individuels doivent être interprétés comme des indicateurs, ou lorsqu'une plage spécifique de bits dans un entier a une signification spéciale et que vous souhaitez extraire uniquement ceux-ci. Vous pouvez effectuer une grande partie de la programmation quotidienne sans jamais avoir besoin d'utiliser ces opérateurs, mais si vous devez travailler avec des données au niveau du bit, une bonne connaissance de ces opérateurs est inestimable.

C'est XOR au niveau du bit, Java n'a pas d'opérateur d'exponentiation, vous devriez utiliser à la Math.pow()place.

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' XORopérateur au niveau du bit.

Beaucoup de gens ont déjà expliqué ce que c'est et comment il peut être utilisé, mais en dehors de l'évidence, vous pouvez utiliser cet opérateur pour faire beaucoup d'astuces de programmation comme

• Le XOR de tous les éléments d'un tableau booléen vous dirait si le tableau a un nombre impair d'éléments vrais
• Si vous avez un tableau dont tous les nombres se répètent un nombre pair de fois, sauf un qui se répète un nombre impair de fois, vous pouvez le trouver en XORant tous les éléments.
• Échange de valeurs sans utiliser de variable temporaire
• Recherche d'un nombre manquant compris entre 1 et n
• Validation de base des données envoyées sur le réseau.

Beaucoup de ces astuces peuvent être effectuées en utilisant des opérateurs peu sages, sujet intéressant à explorer.

Comme d'autres l'ont dit, c'est XOR au niveau du bit. Si vous voulez élever un nombre à une puissance donnée, utilisez Math.pow(a , b), où aest un nombre et best la puissance.

Règle d'opérateur XOR

0 ^ 0 = 0
1 ^ 1 = 0
0 ^ 1 = 1
1 ^ 0 = 1

L'opérateur au niveau du bit fonctionne sur les bits et effectue des opérations bit par bit. Supposons que 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

Le lien d'AraK pointe vers la définition de exclusif-or, qui explique comment cette fonction fonctionne pour deux valeurs booléennes.

L'information manquante est de savoir comment cela s'applique à deux entiers (ou valeurs de type entier). Le bit exclusif ou est appliqué aux paires de chiffres binaires correspondants en deux nombres, 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 XOR au niveau du bit est de dire que le résultat a un 1 à chaque endroit où les deux nombres d'entrée diffèrent.

Avec 4 et 5, la seule différence est à la dernière place; alors

0101 ^ 0100 = 0001 (5 ^ 4 = 1).

Vous pouvez utiliser Math.pow à la place:

https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Math.html#pow%28double,%20double%29

Comme déjà indiqué par 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

C'est l'opérateur Bitor xor en java qui donne 1 pour une valeur de bit différente (ie 1 ^ 0 = 1) et 0 pour la même valeur de bit (ie 0 ^ 0 = 0) quand 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.

Une façon simple de définir Bitwise XOR consiste à dire que le résultat a un 1 à chaque endroit où les deux nombres d'entrée diffèrent.

0101 ^ 0100 = 0001 (5 ^ 4 = 1).

C'est parce que vous utilisez l'opérateur xor.

En java, ou à peu près n'importe quelle autre langue, ^ est xor au niveau du bit, donc bien sûr,

10 ^ 1 = 11. plus d'informations sur les opérateurs au niveau du bit

Il est intéressant de noter que Java et C # n'ont pas d'opérateur puissant.

C'est l'opérateur xor au niveau du bit en java qui donne 1 pour une valeur différente (ie 1 ^ 0 = 1) et 0 pour la même valeur (ie 0 ^ 0 = 0).

^ est un xor binaire (comme dans la base-2), pas une exponentiation (qui n'est pas disponible en tant qu'opérateur Java). Pour l'exponentiation, voir java.lang.Math.pow ().

Il s'agit d'un opérateur XOR. Il est utilisé pour effectuer des opérations binaires sur des nombres. Il a un comportement tel que lorsque vous effectuez une opération xor sur les mêmes bits, dites 0 XOR 0/1 XOR 1, le résultat est 0. Mais si l'un des bits est différent, le résultat est 1. Donc, lorsque vous avez fait 5 ^ 3, vous peut regarder ces nombres 5, 6 sous leurs formes binaires et ainsi l'expression devient (101) XOR (110) qui donne le résultat (011) dont la représentation décimale est 3.

Dans d'autres langues comme Python, vous pouvez faire 10 ** 2 = 100, essayez-le.