comment faire pour acceder directement aux byte d'un entier?

Version imprimable

Voilà,
un int est codé sur 32 bits. Je souhaiterais accéder directement à ces bits pour faire la conversion entre un entier et les 4 bytes correspondant. Parce que pour le moment je refais le calcul.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class ByteBufferConsol {
	private byte[] b;
	private int index;
	private final static int B3 = (int) Math.pow(256, 3);
	private final static int B2 = (int) Math.pow(256, 2);
	private final static int B1 = 256;
 
	public ByteBufferConsol() {
		b = new byte[1000];
		index = 0;
	}
 
	public ByteBufferConsol(int capacity) {
		b = new byte[capacity];
		index = 0;
	}
 
	public void putInt(int i) {
		int res, j;
		res = i;
		j = res / B3;
		res = res - j;
		b[index++] = (byte) j;
		j = res / B2;
		res = res - j;
		b[index++] = (byte) j;
		j = res / B1;
		res = res - j;
		b[index++] = (byte) j;
		b[index++] = (byte) res;
	}
 
	public int getInt() {
		int result;
		result = b[index++] * B3 + b[index++] * B2 + b[index++] * B1 + b[index++];
		return (result);
	}
 
	public void putInt(int i, int offset) {
		index = offset;
		putInt(i);
	}
 
	public int getInt(int offset) {
		index = offset;
		return getInt();
	}
 
}

Merci d'avance.

Code:

1
2
3
4
5
6
7
8
9
10
 
int i = 1234567;
byte[] b = new byte[]{
    (byte)(i & 0xFF),
    (byte)((i & 0xFF00) >> 8),
    (byte)((i & 0xFF0000) >> 16),
    (byte)((i & 0xFF000000) >> 24)
}
int j = b[0]+b[1]<<8+b[2]<<16+b[3]<<24;
// i == j

Parfait,
C'est exactement ce que je cherchais :P

Merci.

Juste une petite correction:

Code:

1
2
3
4
5
6
7
8
9
		int i = 1234567;
		byte[] b = new byte[]{
		    (byte)(i & 0x000000FF),
		    (byte)((i & 0x0000FF00) >> 8),
		    (byte)((i & 0x00FF0000) >> 16),
		    (byte)((i & 0xFF000000) >> 24)
		};
		int j = (b[0]&0x000000FF)+((b[1]<<8)&0x0000FF00)+ ((b[2]<<16)&0x00FF0000)+((b[3]<<24)&0xFF000000);
		System.out.println(j);

il faut juste rajouter 0x000000FF ... pour eviter la propagation du signe
En effet:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
		int i = 0x00000082;
		System.out.println(i); // affiche 130.
		System.out.println(Integer.toHexString(i)); // affiche 82 qui est la representation hexadecimal de 130.
		byte[] b = new byte[]{
		    (byte)(i & 0x000000FF),
		    (byte)((i & 0x0000FF00) >> 8),
		    (byte)((i & 0x00FF0000) >> 16),
		    (byte)((i & 0xFF000000) >> 24)
		};
		System.out.println(b[0]); // affiche -126. En fait le bit de poid le plus fort dans un byte est utilisé pour le signe.
		System.out.println(Integer.toHexString(b[0])); // affiche FFFFFF82 car b[0] est convertit en int avec propagation du signe du byte dans l'integer.
		System.out.println(Integer.toHexString(b[0] & 0x000000FF)); // affiche 00000082 pas de propation du signe.
 
		// remarque
		byte un_byte = (byte)0x82;
		System.out.println(un_byte == 0x82);// affiche false parce que dans un byte on tient compte du signe.
 
		int j = (b[0]&0x000000FF)+((b[1]<<8)&0x0000FF00)+ ((b[2]<<16)&0x00FF0000)+((b[3]<<24)&0xFF000000);
		System.out.println(j);
		System.out.println(b[0] & 0x000000FF);

Merci:P

par contre j'ai modifier la dernière ligne en changeant les additions par des |
et je me demandais si c'était plus rapide.

Code:

int j = (b[0]&0x000000FF)|((b[1]<<8)&0x0000FF00)| ((b[2]<<16)&0x00FF0000)|((b[3]<<24)&0xFF000000);