Operadores Bit a Bit em Java

Os operadores bit a bit operam diretamente sobre os bits individuais de valores inteiros. Apenas tipos inteiros podem ser utilizados como operandos nesse tipo de operação.

Todo número possui uma representação binária. Por exemplo, o número 4 é representado em binário como 100, e o número 5 como 101.

Considere as seguintes declarações:

byte b = 7;     // 0000 0111
short s = 7;    // 0000 0000 0000 0111

O tipo byte ocupa 1 byte (8 bits) e, portanto, é representado por 8 posições binárias. Assim, o valor da variável b é 0000 0111. O tipo short ocupa 2 bytes (16 bits), então o valor da variável s é representado como 0000 0000 0000 0111.

Java utiliza o sistema de complemento de dois para representar números com sinal. Nesse sistema, o bit mais à esquerda (mais significativo) é o bit de sinal. Quando ele é 0, o valor é positivo e sua representação binária é idêntica à de um número sem sinal. Por exemplo, 0000 0001 corresponde a 1. Quando o bit de sinal é 1, o valor é interpretado como negativo. Por exemplo, 1111 1111 representa -1 e 1111 0011 representa -13.

Operadores Lógicos Bit a Bit

Esses operadores atuam sobre os valores binários dos operandos. Por exemplo, o número 2 é 10 em binário, com dois bits, e o número 7 é 111, com três bits.

• & (E bit a bit)

  Compara cada par de bits correspondentes. O resultado é 1 apenas quando ambos os bits são 1; caso contrário, é 0.

  content_copyopen_in_new

  int a1 = 2; // 010
  int b1 = 5; // 101
  System.out.println(a1 & b1); // resultado: 0 (000)
  
  int a2 = 4; // 100
  int b2 = 5; // 101
  System.out.println(a2 & b2); // resultado: 4 (100)

  No primeiro exemplo, os bits de 2 (010) e 5 (101) não têm posições correspondentes com valor 1, então o resultado é 000, que equivale a 0.

  a1	b1	a1 & b1
  0	1	0
  1	0	0
  0	1	0

  No segundo exemplo, apenas o primeiro bit é 1 em ambos os valores, resultando em `100`, que corresponde a 4.

  a2	b2	a2 & b2
  1	0	0
  1	0	1
  1	0	0

• | (OU bit a bit) Retorna 1 em cada posição onde pelo menos um dos bits correspondentes seja 1.

  content_copyopen_in_new

  int a1 = 2; // 010
  int b1 = 5; // 101
  System.out.println(a1 | b1); // resultado: 7 (111)
  
  int a2 = 4; // 100
  int b2 = 5; // 101
  System.out.println(a2 | b2); // resultado: 5 (101)

  No primeiro exemplo, o resultado é 111, equivalente a 7.

  a1	b1	a1 | b1
  0	1	1
  1	0	1
  0	1	1

  No segundo exemplo, o resultado é `101`, equivalente a 5.

  a2	b2	a2 | b2
  1	1	1
  0	0	0
  0	1	1

• ^ (OU exclusivo bit a bit, XOR)

  Retorna 1 apenas quando os bits correspondentes são diferentes. Esse operador é amplamente utilizado em criptografia simples.

  content_copyopen_in_new

  int number = 45;         // 101101
  int key = 102;           // 1100110
  int encrypt = number ^ key;
  System.out.println("Encrypted: " + encrypt); // resultado: 75 (1001011)
  
  int decrypt = encrypt ^ key;
  System.out.println("Decrypted: " + decrypt); // resultado: 45 (101101)

  Nesse exemplo, number ^ key gera o valor criptografado. A aplicação do mesmo operador com a mesma chave sobre o valor criptografado recupera o valor original. Encrypt:

  number	key	encrypt (XOR)
  0	1	1
  1	1	0
  0	0	0
  1	0	1
  1	1	0
  0	1	1
  1	0	1

  Decrypt:

  encrypt	key	decrypt (XOR)
  1	1	0
  0	1	1
  0	0	0
  1	0	1
  0	1	1
  1	1	0
  1	0	1

• ~ (negação bit a bit)

  Inverte todos os bits do valor. Cada bit 1 se torna 0 e cada bit 0 se torna 1.

  content_copyopen_in_new

  byte a = 12;                 // 0000 1100
  System.out.println(~a);     // 1111 0011 (equivale a -13)

  A negação dos bits de 12 (00001100) resulta em 11110011, que representa -13 no sistema de complemento de dois.

Operadores de Deslocamento

Esses operadores deslocam os bits para a esquerda ou para a direita.

• O operador << realiza o deslocamento para a esquerda, o que equivale a uma multiplicação por 2 a cada posição deslocada.

  content_copyopen_in_new

  System.out.println(4 << 1); // resultado: 8

  Nesse exemplo, o número 4 (100 em binário) é deslocado uma posição para a esquerda, resultando em 1000, que corresponde a 8.

• O operador >> realiza o deslocamento para a direita, preservando o bit de sinal. O valor é dividido por 2 a cada posição deslocada.

  content_copyopen_in_new

  System.out.println(16 >> 1); // resultado: 8

  Nesse exemplo, o número 16 (10000 em binário) é deslocado uma posição para a direita, resultando em 1000, que corresponde a 8.

• O operador >>> também desloca os bits para a direita, mas sem preservação do sinal. O valor é tratado como se fosse sem sinal.

  content_copyopen_in_new

  System.out.println(-8 >>> 2); // resultado: 1073741822

O deslocamento de bits pode ser interpretado como uma forma eficiente de multiplicar ou dividir por potências de dois. Em nível de hardware, essas operações exigem menos recursos computacionais do que multiplicações ou divisões convencionais, sendo vantajosas em contextos de otimização de desempenho.

Resumo

• Operadores bit a bit operam sobre bits de inteiros.
• Java usa complemento de dois para representar números negativos.
• & retorna 1 se ambos os bits forem 1.
• | retorna 1 se pelo menos um bit for 1.
• ^ (XOR) retorna 1 se os bits forem diferentes.
• ~ inverte todos os bits (negação).
• << desloca bits à esquerda (multiplica por 2).
• >> desloca à direita preservando o sinal.
• >>> desloca à direita sem sinal.