Olá Pessoal, tudo bom?
Continuando nossa descrição básica sobre os operadores no Java, hoje é dia de falar sobre o operador bitwise AND. Esse operador, em conjunto com outros operadores Bitwise são raramente utilizados, eu particularmente nunca utilizei-os em um projeto profissional. Assim esse artigo será um pouco mais extenso que os outros, mas para que todos possam entender. A oitava parte desse artigo se encontra aqui. Confira na continuação desse artigo sobre o operador bitwise AND:
Operadores Bitwise
Bitwise é uma técnica que consiste, basicamente, em alterar a sequência de bits de uma instância. Normalmente isso é aplicado sobre representações de tipos primitivos de um número inteiro como long, int, short e byte, mas também pode ser aplicado ao tipo char.
Para trabalhar um pouco sobre essa técnica, nós precisamos descrever um pouco sobre matemática binária:
0 + 0 = 0
0 + 1 = 1
1 + 1 = 10
Como em Java um tipo primitivo que represente um inteiro é 32 bits. Dessa forma o bit com maior valor, primeiro da esquerda para direita, representa o sinal de positivo ou negativo. Os outros 31 bits podem representar qualquer número no intervalo -231 até o 231 – 1. De acordo com o artigo sobre tipos primitivos o int:
É um valor 32-bits inteiro assinado com complemento de dois. Seu intervalo de valores vai do -231 até o 231 – 1. A partir do Java 8 é possível representar o inteiro como um valor 32-bits não assinado, ou seja, somente para valores positivos que possuem o intervalo do 0 ao 232 – 1. Para conseguir representar como um inteiro positivo utilizar a classe wrapper java.lang.Integer.
Operador Bitwise AND
O operador bitwise AND é definidor pelo simbolo abaixo:
Operador | Descrição |
---|---|
& | Operador Bitwise para operações Bitwise do tipo AND |
Para realizar o seu processo o operador aplica a tabela verdade do AND, conforme tabela abaixo, a qual indica que o bit será 1 apenas se ambos forem 1:
Bit 1 | Bit 2 | AND – Valor Final |
---|---|---|
0 | 0 | 0 |
0 | 1 | 0 |
1 | 0 | 0 |
1 | 1 | 1 |
Normalmente o Bit 1 pertence a uma instância que representa o valor (flag) a ser validado e o Bit 2 pertence a uma instância que representa a máscara de bits (bitmask). Mas porque o nome bitmask? Quando o AND é realizado, os bits zero na máscara escondem os bits um do flag. Se você pensar que os bits que possuem valor zero na máscara são opacos e os bits que possuem valor um são transparentes, somente os transparentes poderão ser visualizados, como buracos em uma máscara:
1 2 3 4 |
1 0 0 1 0 1 1 0 (Flag) AND 0 0 0 0 0 0 1 0 (Bitmask) --------------- 0 0 0 0 0 0 1 0 (Resultado da operacao) |
Abaixo temos uma classe de exemplo que trabalha com o operador bitwise AND:
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package br.com.mauda.operadores; public class OperadorBitwiseAND { public static void main(String[] args) { int bitmask = 0x000F; //Em binario 0000 0000 0000 1111 int flag = 0x2222; //Em binario 0010 0010 0010 0010 // =================== //Em binario 0000 0000 0000 0010 int resultado = flag & bitmask; System.out.println("Resultado da operacao bitwise AND: " + resultado); } } |
O resultado da execução dessa classe será o seguinte:
1 |
Resultado da operacao bitwise AND: 2 |
Precedência dos Operadores
Continuando a formular a tabela de precedência, agora segue o operador bitwise AND, o qual está abaixo dos operadores de igualdade, assim verifique a tabela abaixo:
Ordem | Tipo de Operador | Precedência |
---|---|---|
1 | Pós Fixo | expr++ expr– |
2 | Pré fixo e Unário | ++expr –expr +expr -expr ! |
3 | Multiplicativo | * / % |
4 | Aditivo | + – |
5 | Relacional | > >= <= < instanceof |
6 | Igualdade | == != |
7 | Bitwise AND | & |
8 | AND Lógico | && |
9 | OR Lógico | || |
10 | Ternário | ? : |
11 | Atribuição | = += -= *= /= %= |
finnaly{
Duvidas ou sugestões? Deixe seu feedback! Isso ajuda a saber a sua opinião sobre os artigos e melhorá-los para o futuro! Isso é muito importante!
Até um próximo post!
Excelente explicação.
Olá Felipe, tudo bom?
Obrigado pelo feedback! Isso significa muito pra mim!
Precisando estamos por aqui!
Obrigado!