Java Xor

Les opérateurs de bitwise sont généralement utilisés pour manipuler ou interroger l'arbre indexé binaire. Ils sont employés pour effectuer les opérations sur des bits séparés. Nous pouvons les utiliser sur n'importe quel type de données intégral, y compris int, char, short, etc. Nous couvrirons l'un des opérateurs de bitwise qui est l'opérateur XOR de Java. Le XOR qui est également appelé exclusif ou nécessite deux opérandes booléens. La vraie forme du XOR est retournée lorsque les opérandes contiennent des valeurs différentes. L'opérateur XOR est le plus efficace lorsque aucune des deux conditions booléennes données n'est vraie en même temps.

Exemple 1:

L'opérateur binaire XOR est calculé de gauche à droite lorsqu'il est utilisé pour le programme. L'opérateur XOR «^» n'est pas défini pour les arguments de type de données de chaîne.

classe publique xorexample1
public static void main (String [] args)
booléen val1 = true;
booléen val2 = false;
Résultat booléen = VAL1 ^ VAL2;
Système.dehors.println ("Val1 Val2:" + Result);
val1 = true;
val2 = true;
Résultat = val1 ^ val2;
Système.dehors.println ("Val1 ^ val2:" + résultat);
val1 = false;
val2 = false;
Résultat = val1 ^ val2;
Système.dehors.println ("Val1 Val2:" + Result);
val1 = true;
val2 = false;
Résultat = val1 ^ val2;
Système.dehors.println ("Val1 ^ val2: '+ résultat);

Nous créons les variables booléennes «VAL1» et «VAL2» qui reçoivent les valeurs booléennes. La variable «Résultat» du type booléen est définie qui est utilisée avec l'opérateur XOR pour évaluer le XOR sur les opérandes «Val1» et «Val2». La méthode println () imprime les résultats de l'opération XOR. Ensuite, nous modifions les valeurs booléennes de l'opérande et attribuons les fausses valeurs pour obtenir des résultats différents. Ensuite, nous fournissons les valeurs booléennes alternatives à ces opérandes pour montrer la fonctionnalité de l'opérateur XOR lorsqu'un opérande a une vraie valeur et l'autre a une fausse valeur.

Les différents cas pour l'opérateur XOR génèrent des résultats différents. Les valeurs booléennes similaires donnent toujours de fausses valeurs et les différentes valeurs de l'opérande renvoient toujours vrai pour l'opérateur XOR.

Exemple 2:

L'opérateur XOR pour les valeurs booléennes des opérandes est démontrée dans le premier exemple. Maintenant, l'opérateur XOR peut également être appliqué à la valeur numérique pour le fonctionnement de XOR.

classe publique xorexample2
public static void main (String [] args)
int a = 8;
int b = 2;
Système.dehors.println ("a ^ b =" + (a ^ b));

Nous déclarons la variable «A» de type int qui est spécifié avec la valeur entière «8». La variable suivante qui est «B» est également initialisée avec la valeur de nombre «2». Après cela, nous utilisons la méthode println () de Java pour effectuer l'opération XOR sur les variables précédemment spécifiées en appelant l'équation XOR qui est évaluée et imprimée.

La valeur binaire de «8» est «1000». Et la valeur binaire pour «2» est «10». Le résultat obtenu sous forme binaire pour ces opérandes est «1010» qui est la valeur de «10» qui est affichée dans le terminal suivant:

Exemple 3:

Le XOR des cordes binaires peut être déterminée en utilisant notre méthode qui utilise l'opérateur XOR et une autre logique. L'opérateur XOR est utilisé pour les deux chaînes en faisant simplement une boucle à travers chaque personnage dans les deux cordes en même temps. Tenez compte du fait que XOR peut fonctionner sur les types de données Char et renvoie 0 si les caractères sont similaires.

classe publique xorexample3
String statique public xorbinarystring (String BS1, chaîne BS2)
String x = "";
if (bs1.length ()> bs2.longueur())
String temp = "";
pour (int i = 0; i bs1.longueur())
String temp = "";
pour (int i = 0; i< bs2.length() bs1.length(); i++)
temp + = "0";
bs1 = temp + bs1;

pour (int i = 0; i< bs1.length(); i++)
X + = bs1.charat (i) ^ bs2.Charat (i);

retour x;

public static void main (String [] args)
Système.dehors.println ("1011 ^ 1111:" + xorbinarystring ("1011 ^ 1111"));
Système.dehors.println ("1 ^ 111101:" + xorbinarystring ("1 ^ 11101"));
Système.dehors.println ("0101 ^ 1:" + xorbinarystring ("0101 ^ 1"));
Système.dehors.print ("10000010 ^ 0:" + xorbinarystring ("1000001 ^ 0") + "\ n");

Nous construisons la fonction «XorbinaryString» qui prend les variables BS1 et BS2 du type de chaîne comme un argument de constructeur. Dans la fonction «xorbinarystring», nous déclarons la variable «x» qui contient initialement une chaîne vide. Après cela, nous avons la déclaration conditionnelle if-else-if pour ajouter le zéro à ces variables de chaîne «bs1» et «bs2» pour que la longueur des cordes binaires soit égale. Ensuite, nous avons le déploiement à boucle forte qui traverse chaque caractère des cordes binaires «BS1» et «BS2» et utilisez ces cordes binaires avec l'opérateur XOR pour obtenir les résultats XOR d'eux. La méthode principale () est utilisée pour attribuer les valeurs binaires aux cordes binaires en appelant la fonction «xorbinarystring».

Les résultats de l'opérateur XOR sont obtenus pour la chaîne binaire qui contient les différentes valeurs binaires qui sont obtenues en utilisant la méthode personnalisée.

Exemple 4:

L'opérateur non peut être utilisé pour effectuer la même tâche que l'opérateur XOR en Java. Étant donné que l'opérateur XOR ne renvoie que si les deux conditions sont différentes, l'utilisation de l'opérateur NON nous permet de comparer si la première condition et la deuxième condition sont égales ou non, de retour réalité s'ils ne sont pas égaux et faux sinon.

classe publique xorexample4
public static void main (String [] args)
booléen x1 = true;
booléen x2 = false;
booléen x3 = true;
booléen x4 = false;
if ((x1 = x3))
Système.dehors.println ("L'état de xor est vrai");

autre

Système.dehors.println ("L'état de XOR est faux");

Nous déclarons quelques variables booléennes qui sont intitulées «x1», «x2», «x3» et «x4». Ceux-ci sont initialisés avec les valeurs booléennes. Certains sont spécifiés avec la vraie valeur, et certains contiennent faux. Ensuite, nous avons un bloc de condition IF-Else où nous définissons l'état de l'opérateur non si la variable «x1» n'est pas égale à la variable «x2». La condition spécifiée est efficace pour qu'elle ne nécessite qu'une seule vraie condition pour être vraie. Cependant, sa logique nécessite plusieurs conditions.

La sortie de la voie alternative pour l'opération XOR affiche les résultats suivants:

Exemple 5:

L'opérateur XOR peut également être utilisé pour échanger les valeurs entières sans utiliser une troisième variable. Cette approche acquiert moins de mémoire et a une complexité temporelle plus faible.

classe publique xorexample5
échange de void statique (int m, int n)
Système.dehors.println ("avant d'échanger.");
Système.dehors.println ("m =" + m);
Système.dehors.println ("n =" + n);

m ^ = n;
n ^ = m;
m ^ = n;
Système.dehors.println ("après échange.");
Système.dehors.println ("m =" + m);
Système.dehors.println ("n =" + n);

public static void main (String [] args)
échange (21, 15);

Nous établissons une fonction «swap ()» à l'intérieur de la classe principale Java. Le constructeur de fonction «swap ()» est spécifié avec les paramètres «m» et «n». Après cela, nous imprimons les variables «M» et «N» pour montrer les valeurs avant l'opération d'échange. Ensuite, nous appliquons la technique de swap sur les variables «M» et «N» déclarées à l'aide de l'opérateur XOR. Ensuite, imprimez les valeurs échangées pour les variables «M» et «N». La méthode main () est appelée fonction swap () où nous initialisons les valeurs numériques pour les variables «m» et «n» pour l'échange.

Les valeurs de l'échange avant sont imprimées sur la console avec les résultats de l'opération après l'échange:

Exemple 6:

Maintenant, il y a un scénario complexe de l'opérateur XOR pour rechercher les valeurs non répétées du tableau donné.

classe publique xorexample6
public static int non-repeatingInteger (int [] intarray)
int myxor
intarray [0];
pour (int i = 1; iMyxor = myxor ^ intarray [i];
retourner myxor;

public static void main (String [] args)
int [] myArray = 19, 26, 45, 26, 45, 82, 19;
int non-repeat = non repeatingInteger (MyArray);
Système.dehors.print ("entiers non répétitifs: + non-répétition +" \ n ");

Nous créons la fonction «non repeatingInteger» qui appelle le constructeur pour déclarer le tableau int [] «intarray». Ensuite, dans l'objet «non-RepeatingInteger», nous définissons l'objet «MyXOR» et spécifions le tableau «INTARRAY» de longueur zéro qui est initialisé avec les valeurs entières dans la méthode principale (). Le tableau est défini avec des valeurs en double sauf pour une valeur. La boucle for-il est utilisée pour obtenir les valeurs des tableaux. Ensuite, ces valeurs de tableau sont organisées comme (19 ^ 19) ^ (26 ^ 26) ^ (45 ^ 45) ^ 82 dans la variable «myxor». Comme nous le savons, l'opérateur XOR renvoie zéro pour des valeurs similaires. Ainsi, toutes les valeurs similaires du tableau deviennent nulles et la valeur non similaire est obtenue à partir du XOR.

Le nombre qui n'est pas répété dans le tableau est «82» que nous avons récupéré à l'intérieur du terminal après la technique XOR.

Conclusion

Nous avons couvert les principes fondamentaux de l'opération XOR dans cet article. Il acquiert moins d'opérateurs à forte intensité de mémoire et est plus simple à mettre en œuvre. Nous avons utilisé l'opérateur XOR dans le programme donné de Java. On nous donne également une technique pour déterminer les valeurs XOR des cordes binaires.