Operadores bitweew em java | Explicado
Como os operadores bit new trabalham em java
Esta seção apresenta a sintaxe e o funcionamento de cada operador bit no Java.
Bitwise e (&): Este operador está relacionado à lógica e operação de Java. No entanto, o Bitwise e o operador comparam os bits de operandos e retorna 1 se ambos os números tiverem 1 no mesmo local. Se os bits no mesmo local tiverem diferente da combinação 1,1, ele substituirá 0 no bit resultante. A sintaxe fornecida abaixo ajuda na aplicação de bit e operação em java.
Operand1 & Operand2;Bit nessa ou (|): Este operador compara bits de operandos e retorna 1 se os operandos tiverem outros 0,0 bits no lugar. O Bitwise ou é praticado usando a seguinte sintaxe:
operand1 | operand2;Bitwise xor (^): Isso funciona de maneira diferente de bit ou bit e bit e. Ele retorna 1 se ambos os operando tiverem bits diferentes e retornará 0 no caso dos mesmos bits de operandos. A sintaxe a seguir deve ser seguida para exercer o XOR bit -bitwe:
operand1 ^ operand2;Complemento bit (~): Complemento bit -bones (~). Isso se refere a alterar os bits de um número de 0 para 1 e 1 para 0. A sintaxe fornecida abaixo deve ser seguida para aplicar o operador de complemento bit -bit:
~ operando;Observação: O compilador Java leva o complemento do 2 para usar o operador de complemento bit.
Operador de turno à esquerda bit -bit (bit<<): Este operador muda o pouco de número para a esquerda por um número específico. A sintaxe a seguir deve ser seguida para aplicar o operador de turno esquerdo:
operand1<Mudança direita sem riacho bitweew (>>>): Isso também se refere a mudar para a direita, ocupando o espaço vago com “0““. A sintaxe fornecida abaixo pode ser usada para aplicar o operador não assinado bit -bit:
operand1 >> operand2;Ao lidar com os operadores de turno, é recomendável que operand2 seja menor que o Operand1, caso contrário, um erro pode ser retornado. Além disso, os números negativos não podem ser usados para aplicar os operadores de turno, pois o resultado pode ser infinito.
Como usar operadores bitwise em java
Esta seção fornece a implementação de vários operadores bit -bittis em java.
Usando Bitwise ou (|): O código Java escrito abaixo é praticado usando o bitwise ou o operador.
pacote newpack;classe pública BitwiseOP
public static void main (string [] args)
// Inicializando variáveis
int a = 4, b = 6;
// imprimindo o binário de variável a
Sistema.fora.println (número inteiro.tobinarystring (a));
// imprimindo o binário da variável b
Sistema.fora.println (número inteiro.tobinarystring (b));
// usando o operador ou em A e B
Sistema.fora.println ("o resultado de um | bis:" +(a | b));
// imprimindo o binário de A | B
Sistema.fora.println (número inteiro.tobinarystring (a | b));
A descrição do código é:
- inicializando duas variáveis a e b
- imprimindo os binários de variáveis, a e b
- imprime o resultado de a | b
- recebe o binário de a | b
Observação: Imprimir/obter o binário do número inteiro no código acima é opcional. Nós o usamos para melhor compreensão, caso contrário, o Java executa automaticamente as operações bitwise no binário equivalente do número.
A saída do código é fornecida abaixo:
A saída mostra que os números binários de “a = 4” e “b = 6” são "100" e "110", respectivamente. E quando o operador "ou" é aplicado, o resultado é 6 e seu binário equivalente é "110".
Usando Bitwise e (&): Para demonstrar o uso do Bitwise e praticamos o seguinte código Java.
pacote newpack;classe pública BitwiseOP
public static void main (string [] args)
// Inicializando variáveis
int x = 5, y = 7;
// imprimindo o binário da variável x
Sistema.fora.println (número inteiro.tobinarystring (x));
// imprimindo o binário da variável y
Sistema.fora.println (número inteiro.tobinarystring (y));
// usando o operador e em x e y
Sistema.fora.println ("O resultado de x & y é:" +(x & y));
// imprimindo o binário de x & y
Sistema.fora.println (número inteiro.tobinarystring (x & y));
O código acima mencionado é descrito como:
- Inicializa duas variáveis x e y
- imprimindo o binário de x
- imprimindo o binário de y
- aplicando & operador em x,y
- imprimiu o binário de x & y
A saída do código acima é mostrada abaixo:
A partir da saída, observa -se que o binário de "x = 5" e "y = 7" é "101" e "111", respectivamente. Quando bitwise E é aplicado neles, o resultado é "5", que tem um valor binário "101".
Usando complemento bit -bowe (~): O operador de complemento bit é usado no código fornecido explodido.
pacote newpack;classe pública BitwiseOP
public static void main (string [] args)
// Inicializando a variável
int z = 2;
// usando o operador ~ em z z
Sistema.fora.println ("O resultado de ~ z é:" + ~ z);
O código acima recebe o valor de z = 2 e imprime o complemento bit a bit de z.
A saída pode ser vista abaixo:
Usando o turno esquerdo Bitwise (<<): Praticamos o seguinte código Java para implementar o operador de turno de esquerda bittusco.
pacote newpack;classe pública BitwiseOP
public static void main (string [] args)
// Inicializando a variável
int a = 4;
// binário de um
Sistema.fora.println (número inteiro.tobinarystring (a));
// usando a mudança esquerda bit a bit em um
Sistema.fora.println (a<<2);
// binário de um<<2
Sistema.fora.println (número inteiro.TobinaryString (a<<2));
O código acima é descrito abaixo:
- a A variável é inicializada
- imprimiu o binário de a
- Usando o operador de mudança de bit a
- Obtendo o binário de a<<2 (Número de bits que serão deslocados)
A saída do código é mostrada abaixo:
A partir da saída, observa -se que o binário de "a = 4" é "100" e quando 2 bits são deslocados, o binário seria "10000" e seu decimal equivalente seria "16".
Usando Bitwise Right Shift (>>): A aplicabilidade do operador de mudança correta é descrito no código a seguir.
pacote newpack;classe pública BitwiseOP
public static void main (string [] args)
// Inicializando a variável
int a = 7;
// binário de um
Sistema.fora.println (número inteiro.tobinarystring (a));
// Usando a mudança à direita bit a bit em um
Sistema.fora.println (a >> 2);
// binário de um >> 2
Sistema.fora.println (número inteiro.tobinarystring (a >> 2));
O código é descrito como:
- variável a é inicializado
- binário de a está impresso
- Mudança direita aplicada em a
- imprimiu o binário de A >> 2.
A saída do código é fornecida aqui:
A saída mostra que os 2 bits certos são removidos de "111" (binário de 7) e o binário resultante é "1".
Usando Bitweew Mude à direita não assinada (>>>): O código a seguir mostra o uso do operador de mudança direita sem assinatura bit -bit -bow.
pacote newpack;classe pública BitwiseOP
public static void main (string [] args)
// Inicializando a variável
int x = 11;
// binário de x
Sistema.fora.println (número inteiro.tobinarystring (x));
// Usando a mudança direita sem assinatura bittudo em x
Sistema.fora.println (x >>> 2);
// binário de x >>> 2
Sistema.fora.println (número inteiro.tobinarystring (x >>> 2));
A descrição do código é como:
- inicializou uma variável x
- imprimiu o binário de x
- imprimiu o resultado de x >>> 2
- obteve o binário de x >>> 2
A saída pode ser vista na imagem a seguir:
O operador de mudança direto não assinado se move a parte para a direita e o espaço vago é ocupado por 2 (como definimos o número de bits para 2) 0. Além disso, é observado a partir da saída que os 2 bits mais à direita são removidos.
Conclusão
Os operadores bitwise em Java são praticados executando várias operações em padrões bitwise. O padrão bitwise considera os bits para manipular os dados. Este artigo demonstra vários operadores bit -bitwise em java. Os operadores bitwee. Você teria aprendido o trabalho básico e o uso de todos esses operadores bit -bitw.