Java XOR

Os operadores bitwise são normalmente usados ​​para manipular ou consultar a árvore indexada binária. Eles são empregados para realizar as operações em bits separados de números. Podemos usá -los em qualquer tipo de dados integral, incluindo int, char, curto, etc. Abordaremos um dos operadores bitwise, que é o operador XOR de Java. O XOR, que também é denominado exclusivo ou requer dois operandos booleanos. A forma verdadeira do XOR é retornada quando os operandos mantêm valores diferentes. O operador XOR é mais eficaz quando nenhuma das duas condições booleanas é verdadeira ao mesmo tempo.

Exemplo 1:

O operador binário XOR é calculado da esquerda para a direita quando usado para o programa. O operador XOR “^” está indefinido para os argumentos do tipo de dados da string.

classe pública xorexample1
public static void main (string [] args)
boolean val1 = true;
boolean val2 = false;
resultado booleano = val1 ^ val2;
Sistema.fora.println ("val1 val2:"+ resultado);
val1 = true;
val2 = true;
Resultado = val1 ^ val2;
Sistema.fora.println ("val1 ^ val2:"+ resultado);
val1 = false;
val2 = false;
Resultado = val1 ^ val2;
Sistema.fora.println ("val1 val2:"+ resultado);
val1 = true;
val2 = false;
Resultado = val1 ^ val2;
Sistema.fora.println ("val1 ^ val2: '+ resultado);

Criamos as variáveis ​​booleanas "Val1" e "Val2", que recebem os valores booleanos. A variável "resultado" do tipo booleano é definida, que é empregada com o operador XOR para avaliar o XOR em operando "Val1" e "Val2". O método println () imprime os resultados da operação XOR. Em seguida, mudamos os valores booleanos do operando e atribuímos os valores falsos para obter resultados diferentes. Em seguida, fornecemos os valores booleanos alternativos a esses operando para mostrar a funcionalidade do operador XOR quando um operando tem um valor verdadeiro e o outro tem um valor falso.

Os diferentes casos para o operador XOR geram resultados diferentes. Os valores booleanos semelhantes sempre dão valores falsos e os diferentes valores do operando sempre retornam verdadeiro para o operador XOR.

Exemplo 2:

O operador XOR para os valores booleanos dos operandos é demonstrado no primeiro exemplo. Agora, o operador XOR também pode ser aplicado ao valor numérico para operação XOR bit netwise.

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

Declaramos a variável "A" do tipo int que é especificado com o valor inteiro "8". A próxima variável que é "B" também é inicializada com o valor do número "2". Depois disso, usamos o método println () de Java para executar a operação XOR nas variáveis ​​especificadas anteriormente chamando a equação XOR que é avaliada e impressa.

O valor binário de "8" é "1000". E o valor binário para "2" é "10". O resultado obtido em forma binária para esses operandos é "1010", que é o valor de "10", que é exibido no terminal seguinte:

Exemplo 3:

O XOR das cordas binárias pode ser determinado usando nosso método que emprega o operador XOR e alguma lógica adicional. O operador XOR é usado para ambas. Leve em consideração que o XOR pode operar nos tipos de dados de char e retorna 0 se os caracteres forem semelhantes.

classe pública xorexample3
public Static String XorbinaryString (String BS1, String BS2)
String x = "";
if (BS1.comprimento ()> BS2.comprimento())
String temp = "";
para (int i = 0; i bs1.comprimento())
String 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);

retornar x;

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

Construímos a função “Xorbinária”, que leva as variáveis ​​BS1 e BS2 do tipo de string como um argumento construtor. Na função "XorbinaryString", declaramos a variável "x" que contém inicialmente uma string vazia. Depois disso, temos a declaração condicional if-else-If para adicionar o zero a essas variáveis ​​de string "BS1" e "BS2" para tornar o comprimento das cordas binárias iguais. Em seguida, temos a implantação do loop for que atravessa cada caractere das cordas binárias “BS1” e “BS2” e usam essas seqüências binárias com o operador XOR para obter os resultados XOR deles. O método Main () é usado para atribuir os valores binários contra as cordas binárias chamando a função "XorbinaryString".

Os resultados do operador XOR são obtidos para a sequência binária que contém os diferentes valores binários que são obtidos usando o método personalizado.

Exemplo 4:

O operador NON pode ser usado para realizar a mesma tarefa que o operador XOR em Java. Como o operador XOR retorna apenas se as duas condições forem diferentes, o uso do operador NO.

classe pública xorexample4
public static void main (string [] args)
booleano x1 = true;
booleano x2 = false;
booleano x3 = true;
booleano x4 = false;
if ((x1 = x3))
Sistema.fora.println ("condição de xor é verdadeiro");

outro

Sistema.fora.println ("condição de xor é falsa");

Declaramos algumas variáveis ​​booleanas intituladas "X1", "X2", "X3" e "X4". Estes são inicializados com os valores booleanos. Alguns são especificados com o valor verdadeiro e outros contêm falsos. Então, temos um bloco de condição IF-ELSE, onde definimos a condição do operador não se a variável "x1" não for igual à variável "x2". A condição especificada é eficiente que apenas requer uma condição verdadeira para ser verdadeira. No entanto, sua lógica requer várias condições.

A saída da maneira alternativa para a operação XOR exibe os seguintes resultados:

Exemplo 5:

O operador XOR também pode ser usado para trocar os valores inteiros sem utilizar uma terceira variável. Esta abordagem adquire menos memória e tem uma complexidade temporal mais baixa.

classe pública xorexample5
Swap de vazio estático (int m, int n)
Sistema.fora.println ("Antes de trocar.");
Sistema.fora.println ("m =" + m);
Sistema.fora.println ("n =" + n);

m ^= n;
n ^= m;
m ^= n;
Sistema.fora.println ("Depois de trocar.");
Sistema.fora.println ("m =" + m);
Sistema.fora.println ("n =" + n);

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

Estabelecemos uma função "swap ()" dentro da classe principal java. O construtor da função "swap ()" é especificado com os parâmetros "m" e "n". Depois disso, imprimimos as variáveis ​​“M” e “N” para mostrar os valores antes da operação de troca. Em seguida, aplicamos a técnica de swap nas variáveis ​​declaradas “m” e “n” usando o operador XOR. Em seguida, imprima os valores trocados para as variáveis ​​“M” e “N”. O método principal () é chamado de função swap (), onde inicializamos os valores numéricos para as variáveis ​​"m" e "n" para trocar.

Os valores de troca antes são impressos no console, juntamente com os resultados da operação após a troca:

Exemplo 6:

Agora, existe um cenário complexo do operador XOR para procurar os valores não repetidos da matriz dada.

classe pública xorexample6
public static int não -repetição (int [] intray)
int myxor
Intarray [0];
para (int i = 1; iMyxor = myxor ^ intarray [i];
retornar myxor;

public static void main (string [] args)
int [] MyArray = 19, 26, 45, 26, 45, 82, 19;
int nonpeat = não -repetição (MyArray);
Sistema.fora.print ("Inteiros não repetidos: + não-repetição +" \ n ");

Criamos a função "não repetição" que chama o construtor a declarar a matriz int [] "INTARRAY". Então, dentro do “não -repetidor”, definimos o objeto “myxor” e especificamos a matriz “Intarray” do comprimento zero, que é inicializada com os valores inteiros no método principal (). A matriz é definida com valores duplicados, exceto por um valor. O loop for usado para obter os valores das matrizes. Então, esses valores da matriz são organizados como (19 ^ 19) ^ (26 ^ 26) ^ (45 ^ 45) ^ 82 Na variável “myxor”. Como sabemos, o operador XOR retorna zero para valores semelhantes. Portanto, todos os valores semelhantes da matriz se tornam zero e o valor não similar é obtido do XOR.

O número que não é repetido na matriz é "82" que recuperamos dentro do terminal após a técnica XOR.

Conclusão

Cobrimos os fundamentos da operação XOR neste artigo. Adquire menos operadores de memória intensiva e é mais simples de implementar. Utilizamos o operador XOR no programa dado de Java. Também recebemos uma técnica para determinar os valores XOR de cordas binárias.