Ope­ra­do­res Java Bitwise: lista e funções

Os ope­ra­do­res Java bit a bit, também co­nhe­ci­dos como ope­ra­do­res Bitwise, permitem manipular bits in­di­vi­du­ais conforme ne­ces­sá­rio. No total, existem sete ope­ra­do­res, todos com uma estrutura muito se­me­lhante. Além disso, as regras que seguem são muito fáceis de entender.

O que são os ope­ra­do­res bitwise do Java e para que servem?

Os ope­ra­do­res Java são uma fer­ra­menta muito im­por­tante se estiver a trabalhar com a linguagem de pro­gra­ma­ção. Entre eles, encontram-se os ope­ra­do­res Java Bitwise, que permitem manipular bits. Se quiser consultar valores binários bit a bit, precisa de um operador Bitwise. Pode aplicá-lo aos tipos de dados inteiros (byte, char, int, short, long).

Embora não vá precisar destes ope­ra­do­res di­a­ri­a­mente, a sua utilidade será evidente em de­ter­mi­na­das situações: por exemplo, se quiser eco­no­mi­zar espaço ao converter dados, se quiser usar o operador XOR ou se quiser alterar um único bit. Além disso, os ope­ra­do­res ao nível do bit têm um grande peso nas operações de circuitos mais complexos. Por tudo isso, vale a pena entender o fun­ci­o­na­mento destes ope­ra­do­res.

Que ope­ra­do­res bitwise existem em Java?

Existem sete ope­ra­do­res Bitwise di­fe­ren­tes em Java. Para com­pre­endê-los melhor, trabalha-se com os operandos «a» e «b».

• ~ (com­ple­mento ou «Bitwise not»): este operador inverte cada bit. Ou seja, um 0 torna-se um 1 e um 1 torna-se um 0.
• & (“Bitwise and”): este operador resulta em 1 se ambos os operandos também forem 1. Caso contrário, é exibido um 0.
• | («Bitwise Or»): este operador resulta em 1 se um dos dois operandos também tiver este valor.
• ^ (XOR ou “Bitwise exclusive OR”): este operador resulta em 0 se os operandos com­pa­ra­dos tiverem o mesmo valor. Caso contrário, gera um 1.
• << (des­lo­ca­mento para a esquerda): este operador desloca o operando “a” para a esquerda em “b” posições. Se houver espaços, eles são pre­en­chi­dos com 0.
• >> (des­lo­ca­mento à direita com sinal, arit­mé­tico): este operador desloca todos os bits de «a» para a direita em «b» posições. Se o bit mais sig­ni­fi­ca­tivo estava definido antes da operação, ele permanece também após a operação, portanto, se o número for negativo, ele continua negativo.
• >>>> (des­lo­ca­mento à direita sem sinal, lógico): este operador desloca os bits de “a” em “b” posições para a direita. Os espaços são sempre pre­en­chi­dos com 0.

Bitwise not

O operador «Bitwise not» do Java é re­pre­sen­tado por um til (~). Ele inverte todos os bits e, portanto, converte zeros em uns e uns em zeros. No exemplo apre­sen­tado abaixo, é utilizado o número decimal 20, que em número binário é: 10100. Ao aplicar o operador, cada bit é invertido, con­ver­tendo 10100 em 01011. Este é o valor da expressão “~20”. Se con­ver­ter­mos novamente este último número binário em um número decimal, obtemos o valor -21. Com o comando Java System.out.println, você pode imprimir o resultado a partir do seguinte código:

public clase Main {
	public static void main(String[] args) {
	int valor1 = 20;
	System.out.println(~Valor1);
}
}

Se tudo tiver sido in­tro­du­zido cor­re­ta­mente, o resultado «-21» deverá ser apre­sen­tado.

E bit a bit

Graças a este operador, dois números são com­pa­ra­dos na sua forma binária, bit a bit. O primeiro bit do primeiro número é comparado com o primeiro bit do segundo número, o segundo bit do primeiro número com o segundo bit do segundo número e assim su­ces­si­va­mente. Se ambos os bits forem 1, também se obtém um 1. Se não for esse o caso (os dois bits são 0 ou apenas um é 0), obtém-se um 0. Para o exemplo apre­sen­tado, são uti­li­za­dos os números decimais 18 e 25 na sua notação binária: 18 é 10010 e 25 é 11001. Agora, os dois números são com­pa­ra­dos entre si para gerar um terceiro número a partir deles. Para uma visão mais clara, escreve-se um abaixo do outro:

18 = 10010 25 = 11001

O primeiro bit de dois números é 1, portanto o resultado também começará por 1. Embora o segundo bit de 25 também seja 1, o segundo bit de 18 é 0, portanto o resultado incluirá um 0 nessa posição. Com­pa­rando os dois números bit a bit, obtém-se fi­nal­mente o número binário 10000. Ao convertê-lo em número decimal, o resultado é 16.

O código ficaria assim:

public clase Main {
	public static void main(String[] args) {
	System.out.println(18&25);
}
}

Na consola seria exibido «16».

Bitwise or

No operador «Bitwise OR» do Java também se comparam bit a bit dois números em notação binária. Neste caso, porém, basta que apenas um dos dois bits com­pa­ra­dos tenha o valor 1 para obter o resultado 1. Como exemplo, tomamos novamente os números 18 e 25 do exemplo anterior:

18 = 10010 25 = 11001

Como todos os bits (exceto o terceiro dígito) contêm pelo menos um 1, este terceiro número resulta em: 11011. Con­ver­tido, obtemos 27.

Em código, este exemplo é re­pre­sen­tado como mostrado:

public clase Main {
	public static void main(String[] args) {
	System.out.println(18|25);
}
}

XOR

XOR ou “Bitwise exclusive OR” (^) é se­me­lhante ao Bitwise OR. No entanto, no caso do XOR, apenas um 1 é impresso se apenas um dos dois bits com­pa­ra­dos for 1. O exemplo torna isso mais claro:

18 = 10010 25 = 11001

Como os dois primeiros bits com­pa­ra­dos com 1, o valor apre­sen­tado é 0. No entanto, o segundo bit de 18 é 0 e o de 25 é 1. Neste caso, obtém-se 1 como resultado, porque apenas um dos dois bits com­pa­ra­dos contém o valor 1. Se continuar, obtém-se 01011. Em notação decimal, cor­res­ponde a 11.

Este é o código cor­res­pon­dente:

public clase Main {
	public static void main(String[] args) {
	System.out.println(18^25);
}
}

Des­lo­ca­mento para a esquerda

Com o des­lo­ca­mento para a esquerda, os bits são des­lo­ca­dos para a esquerda em «b» posições. Os espaços em branco re­sul­tan­tes são pre­en­chi­dos com 0. Se tomarmos como valor «a» o 20, ou seja, 10100 em notação binária, e des­lo­car­mos um valor «b» 2, obtemos o valor c 1010000. Neste caso, é ne­ces­sá­rio incluir dois zeros no final. 1010000 cor­res­ponde ao valor decimal 80.

No código, pode ser visto como mostrado:

public clase Main {
	public static void main(String[] args) {
	int a = 20
	int b = 2
	int c = (a << b);
	System.out.println(c);
}
}

Des­lo­ca­mento para a direita com sinal

O des­lo­ca­mento para a direita funciona no sentido contrário. Des­lo­ca­mos os bits de «a» para a direita em «b» posições e assim obtemos c. Os últimos bits são omitidos. Se des­lo­car­mos 20 ou 10100 duas posições para a direita, o resultado é 00101 ou 5.

O código é:

public clase Main {
	public static void main(String[] args) {
	System.out.println(20 >> 2);
}
}

É im­por­tante destacar que os espaços são pre­en­chi­dos com 0 se a for um número positivo. Se for negativo, os espaços são subs­ti­tuí­dos por 1.

Des­lo­ca­mento para a direita sem sinal

O operador Java Bitewise des­lo­ca­mento à direita sem sinal (>>>) funciona exa­ta­mente da mesma maneira. A única diferença é que os espaços criados no lado esquerdo por um des­lo­ca­mento à direita são sempre pre­en­chi­dos com 0. Con­se­quen­te­mente, sempre se obtém números positivos, mesmo que “a” fosse negativo.