Java Xor

Los operadores bit a bit se usan típicamente para manipular o consultar el árbol indexado binario. Se emplean para llevar a cabo las operaciones en bits de números separados. Podemos usarlos en cualquier tipo de datos integrales que incluyan int, char, short, etc. Cubriremos a uno de los operadores bit a bit que es el operador XOR de Java. El XOR que también se denomina exclusivo o requiere dos operandos booleanos. La verdadera forma del XOR se devuelve cuando los operandos contienen diferentes valores. El operador XOR es más efectivo cuando ninguna de las dos condiciones booleanas dadas es cierto al mismo tiempo.

Ejemplo 1:

El operador binario XOR se calcula de izquierda a derecha cuando se usa para el programa. El operador XOR "^" está indefinido para los argumentos de tipo de datos de cadena.

clase pública xorexample1
public static void main (string [] args)
booleano val1 = verdadero;
booleano val2 = falso;
Resultado booleano = val1 ^ val2;
Sistema.afuera.println ("val1 val2:"+ resultado);
val1 = verdadero;
val2 = verdadero;
Resultado = val1 ^ val2;
Sistema.afuera.println ("val1 ^ val2:"+ resultado);
val1 = falso;
val2 = falso;
Resultado = val1 ^ val2;
Sistema.afuera.println ("val1 val2:"+ resultado);
val1 = verdadero;
val2 = falso;
Resultado = val1 ^ val2;
Sistema.afuera.println ("val1 ^ val2: '+ resultado);

Creamos las variables booleanas "Val1" y "Val2" a los que se les da los valores booleanos. Se define la variable de "resultado" del tipo booleano que se emplea con el operador XOR para evaluar el XOR en los operandos "Val1" y "Val2". El método println () imprime los resultados de la operación XOR. A continuación, cambiamos los valores booleanos del operando y asignamos los valores falsos para obtener diferentes resultados. Luego, proporcionamos los valores booleanos alternativos a estos operandos para mostrar la funcionalidad del operador XOR cuando un operando tiene un valor real y el otro tiene un valor falso.

Los diferentes casos para el operador XOR generan diferentes resultados. Los valores booleanos similares siempre dan valores falsos y los diferentes valores del operando siempre devuelven verdadero para el operador XOR.

Ejemplo 2:

El operador XOR para los valores booleanos de los operandos se demuestra en el primer ejemplo. Ahora, el operador XOR también se puede aplicar al valor numérico para la operación XOR bitwise.

clase pública xorexample2
public static void main (string [] args)
int a = 8;
int b = 2;
Sistema.afuera.println ("a ^ b =" + (a ^ b));

Declaramos la variable "A" de Tipo INT que se especifica con el valor entero "8". La siguiente variable que es "B" también se inicializa con el valor del número "2". Después de eso, utilizamos el método println () de Java para realizar la operación XOR en las variables especificadas previamente llamando a la ecuación XOR que se evalúa e imprime.

El valor binario de "8" es "1000". Y el valor binario para "2" es "10". El resultado obtenido en forma binaria para estos operandos es "1010", que es el valor de "10" que se muestra en el siguiente terminal:

Ejemplo 3:

El XOR de las cadenas binarias se puede determinar utilizando nuestro método que emplea al operador XOR y alguna lógica adicional. El operador XOR se usa para ambas cadenas simplemente recorriendo cada carácter en ambas cadenas al mismo tiempo. Tenga en cuenta que Xor puede operar en los tipos de datos de Char y devuelve 0 si los caracteres son similares.

clase pública xorexample3
public static string xorBinaryString (String BS1, String BS2)
Cadena x = "";
if (bs1.longitud ()> bs2.longitud())
Cadena temp = "";
para (int i = 0; i bs1.longitud())
Cadena temp = "";
para (int i = 0; i< bs2.length() bs1.length(); i++)
temp += "0";
bs1 = temp + bs1;

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

regresar x;

public static void main (string [] args)
Sistema.afuera.println ("1011 ^ 1111:" + XorbinaryString ("1011 ^ 1111"));
Sistema.afuera.println ("1 ^ 111101:" + XorbinaryString ("1 ^ 11101"));
Sistema.afuera.println ("0101 ^ 1:" + XorbinaryString ("0101 ^ 1"));
Sistema.afuera.imprimir ("10000010 ^ 0:" + XorbinaryString ("1000001 ^ 0") + "\ n");

Construimos la función "XorbinaryString" que toma las variables BS1 y BS2 del tipo de cadena como argumento de constructor. En la función "XorbinaryString", declaramos la variable "x" que inicialmente contiene una cadena vacía. Después de eso, tenemos la declaración condicional if-else-if para agregar el cero a estas variables de cadena "BS1" y "BS2" para que la longitud de las cadenas binarias sea igual. Luego, tenemos el despliegue del circuito para el circuito que atraviesa cada carácter de las cuerdas binarias "BS1" y "BS2" y usa estas cadenas binarias con el operador XOR para obtener los resultados XOR de ellas. El método main () se utiliza para asignar los valores binarios contra las cadenas binarias llamando a la función "XorbinarTring".

Los resultados del operador XOR se obtienen para la cadena binaria que contiene los diferentes valores binarios que se obtienen utilizando el método personalizado.

Ejemplo 4:

El no operador no puede usarse para llevar a cabo la misma tarea que el operador XOR en Java. Dado que el operador XOR solo devuelve verdadero si ambas condiciones son diferentes, el uso del operador no nos permite comparar si la primera condición y la segunda condición son iguales o no, devolviendo verdadero si no son iguales y falsos de lo contrario.

clase pública xorexample4
public static void main (string [] args)
booleano x1 = verdadero;
booleano x2 = falso;
booleano x3 = verdadero;
booleano x4 = falso;
if ((x1 = x3))
Sistema.afuera.println ("La condición de Xor es verdadera");

demás

Sistema.afuera.println ("La condición de Xor es falsa");

Declaramos algunas variables booleanas que se titulan "x1", "x2", "x3" y "x4". Estos se inicializan con los valores booleanos. Algunos se especifican con el valor verdadero, y otros contienen falso. Luego, tenemos un bloque de condición if-else donde definimos la condición del operador no si la variable "x1" no es igual a la variable "x2". La condición especificada es eficiente de que solo requiere una verdadera condición para ser verdadera. Sin embargo, su lógica requiere varias condiciones.

La salida de la forma alternativa para la operación XOR muestra los siguientes resultados:

Ejemplo 5:

El operador XOR también se puede usar para cambiar los valores enteros sin utilizar una tercera variable. Este enfoque adquiere menos memoria y tiene una menor complejidad temporal.

clase pública xorexample5
Swap void estático (int m, int n)
Sistema.afuera.println ("antes de intercambiar.");
Sistema.afuera.println ("m =" + m);
Sistema.afuera.println ("n =" + n);

m ^= n;
n ^= m;
m ^= n;
Sistema.afuera.println ("Después de intercambiar.");
Sistema.afuera.println ("m =" + m);
Sistema.afuera.println ("n =" + n);

public static void main (string [] args)
intercambio (21, 15);

Establecemos una función "swap ()" dentro de la clase principal de Java. El constructor de la función "swap ()" se especifica con los parámetros "m" y "n". Después de eso, imprimimos las variables "M" y "N" para mostrar los valores antes de la operación de intercambio. A continuación, aplicamos la técnica de intercambio en las variables declaradas "M" y "N" utilizando el operador XOR. Luego, imprima los valores intercambiados para las variables "M" y "N". El método main () se llama función swap () donde inicializamos los valores numéricos para las variables "m" y "n" para intercambiar.

Los valores de intercambio antes se imprimen en la consola junto con los resultados de la operación después de intercambio:

Ejemplo 6:

Ahora, hay un escenario complejo del operador XOR para buscar los valores no repetidos de la matriz dada.

clase pública xorexample6
public static int no recreatingInteger (int [] Intarray)
int myxor
Intarray [0];
para (int i = 1; iMyxor = myxor ^ intarray [i];
regresar myxor;

public static void main (string [] args)
int [] myArray = 19, 26, 45, 26, 45, 82, 19;
int no repetido = no repetidointeger (myArray);
Sistema.afuera.imprimir ("Integers no repetidos: + no repetido +" \ n ");

Creamos la función de "no receptorintagente" que llama al constructor para declarar la matriz int [] "Intarray". Luego, dentro del "no receptor de Infreger", definimos el objeto "Myxor" y especificamos la matriz "Intarray" de longitud cero que se inicializa con los valores enteros en el método main (). La matriz se establece con valores duplicados, excepto por un valor. El for-loop se usa para obtener los valores de las matrices. Entonces, estos valores de matriz se organizan como (19 ^ 19) ^ (26 ^ 26) ^ (45 ^ 45) ^ 82 en la variable "Myxor". Como sabemos, el operador XOR devuelve cero para valores similares. Entonces, todos los valores similares de la matriz se vuelven cero y el valor no similar se obtiene del XOR.

El número que no se repite en la matriz es "82" que recuperamos dentro del terminal después de la técnica XOR.

Conclusión

Cubrimos los fundamentos de la operación XOR en este artículo. Adquiere menos operadores intensivos en memoria y es más simple de implementar. Utilizamos el operador XOR en el programa dado de Java. También se nos da una técnica para determinar los valores XOR de las cadenas binarias.