Manipulação de bytes

Ninguém?

0x é um prefixo para representação de valores em hexadecimal
0xFF, por exemplo, representa 255 na base 10.

Já as outras operações são chamadas de manipulação de bits.
Dá uma procurada no aqui no fórum sobre deslocamento de bits e operações lógicas com os mesmos, creio que já existem bastantes discussões sobre isso.

Dica: Esboce os valores em um papel representando-os em binário e faça as operações.
Abraço

rodrigo_rosalin:

0x é um prefixo para representação de valores em hexadecimal
0xFF, por exemplo, representa 255 na base 10.

Já as outras operações são chamadas de manipulação de bits.
Dá uma procurada no aqui no fórum sobre deslocamento de bits e operações lógicas com os mesmos, creio que já existem bastantes discussões sobre isso.

Dica: Esboce os valores em um papel representando-os em binário e faça as operações.
Abraço

Eu entendo as operações de deslocamento de AND lógico…Só não entendo por que são aplicadas neste contexto…

Eu posso substituir 0xFF por 255? Tem o mesmo significado? O Java interpreta da mesma forma?

Olhando de cara percebe-se que este algoritmo pega um int(que contem 4 bytes) e joga cada um destes 4 bytes em uma posição do vetor.

suponha-se que eu chame sua função desta forma

ManBytes.encodeInt(1000, buf, bufPos);

00000000 00000000 00000011 11101000 -----> valor 1000 em decimal

//Nesta linha por exemplo.
buf[bufPos+3] = (byte)(value & 0xFF);

Esta operação faz o seguinte.
00000000 00000000 00000011 11101000 AND 00000000 00000000 00000000 11111111

O resultado disso é que você vai zerar 24 bits a esquerda, assim o valor representado será 00000000 00000000 00000000 11101000, lembrando que os zeros a esquerda se tornam irrelevantes, (este valor é convertido para byte e será guardado em buf[bufPos+3]).

//na penúltima linha.
buf[bufPos+2] = (byte)(value >> 8 & 0xFF);

00000000 00000000 00000011 11101000 >> 8
faz com que seja deslocado 8 bits a direita, ficando assim: 00000000 00000000 00000000 00000011
Após esta operação é executado um AND para garantir que todos os outros 24 bits a esquerda sejam 0, assim ele pega novamente o ultimo byte e guarda em buf[bufPos+2].

Seguindo este raciocionio para cada linha do seu codigo você estará deslocando uma quantidade de bits a direita(menos na ultima linha) e garantindo que todos outros bytes a esquerda sejam zero.

buf[0] = 0
buf[1] = 0
buf[2] = 3
buf[3] = -24 (valor esta negativo porque foi convertido para byte que é sempre sinalizado em java).

Escrevi isso bem rapidinho pois estou no trabalho, caso não esteja nenhum pouco didatico avisa que eu tento reescrever quando estiver em casa.

Abraço

Opa! Agora sim saquei! Obrigado pela explicação, colega…Foi de grande ajuda!

Não sei se ainda ajuda, mas fiz uma classe para isso:
http://www.guj.com.br/posts/list/136655.java#736136

Fica o link para caso alguém chegue nesse tópico através da busca…