Discussion :

[Lyra1606]

Bonjour,
J'aimerais convertir une chaine de caractère reçue de type :

String str = "bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb "

en un tableau de bytes

byte[] byte_array = {(byte) 0xBB, (byte) 0xBB, (byte) 0xBB, (byte) 0xBB, (byte) 0xBB, (byte) 0xBB, (byte) 0xBB, (byte) 0xBB,
(byte) 0xBB, (byte) 0xBB, (byte) 0xBB, (byte) 0xBB, (byte) 0xBB, (byte) 0xBB, (byte) 0xBB, (byte) 0xBB};

car j'ai besoin dans la suite de mon code de manipuler ce tableau de bytes et donc d'être sure qu'il contient les bonnes valeurs.

J'ai essayé le petit code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
String str = "bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb ";
		byte [] byte_array = new byte [16];
 
		byte_array = str.getBytes();
		System.out.println(str);
		System.out.println(byte_array.toString());
        for(int i = 0x00; i <= 0x0F; i++)
        	System.out.print(String.format("%x ", byte_array[i]));

Et j'obtiens alors le resultat suivant :

bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb
[B@addbf1
62 62 20 62 62 20 62 62 20 62 62 20 62 62 20 62

Donc pas du tout ma chaine initiale de nombres hexadécimaux.

Si quelqu'un a une idée, je prends avec plaisir.
Merci d'avance

[Catsoumoto]

Enfaîte tu a fait un tableau de 16 bytes, alors que ta chaîne est 3 fois plus longue.

"bb " = 3 caractères

ta chaine devient 62 62 20. 62 ascii de b en hexa et 20 ascii de espace en hexa.

[Lyra1606]

D'accord, mais si je veux obtenir bb comme initialement que faut-il que je fasse ?

[Catsoumoto]

C'est un peu plus chaud mais on y arrive

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
StringBuffer buffer = new StringBuffer();
for(int i = 0x00; i <= 0x0F; i++)        	             
     buffer.append((char)Integer.parseInt(Integer.toHexString(byte_array[i]), 16));
System.out.println(buffer);

et j'obtiens 16 caractère "bb bb bb bb bb b"


Pour l'explication:
Je transforme le byte en string j’obtiens "62"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Integer.toHexString(byte_array[i])

Je transforme l'hexa en ascii (int) j’obtiens "98"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Integer.parseInt(Integer.toHexString(byte_array[i]), 16));

Et transformé l'ascii en char j’obtiens "b"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
(char)Integer.parseInt(Integer.toHexString(byte_array[i]), 16)

[kolodz]

Tu devrait passer par la fonction split

Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
String str = "bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb";
String[] table  str.split(" ");
for(String value : table){
// TODO
Integer integer = hexaStringToInteger("0x"+value);
}

Cordialement,
Patrick Kolodziejczyk.

[Lyra1606]

Merci Catsoumoto, pour ta réponse. J'obtiens bien les lettres bb bb bb... dans ma console mais le problème c'est que le résultat n'est toujours pas dans un tableau de bytes.

Pour la réponse de kolodz le problème est que je ne sais pas comment coder la fonction hexaStringToInteger.

[ludomacho]

Bonjour,

le souci est que java code les byte en signé c'est à dire de -128 à 127 alors que la fonction parse(String,16) te donne un équivalent non signé de 0 à 255. Et comme ca peut dépasser 127 il faut utiliser au moins un short (moi j'ai utilisé un int) pour parser ton string. Ensuite si le bit de poids fort est egal à 1 c'est un nombre négatif il faut donc faire du "complément à 2 inverse" , sinon il suffit de caster l'int en byte.
Je ne pense pas qu'il y ait beaucoup plus simple.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
50
51
52
53
54
 
public class EssaiByte {
 
 
 
 
	public static void main(String[] args) {
		String str = "0f bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb";
		String[] table = str.split(" ");
		byte[] tableauByte = new byte[table.length];
		int temp;
		String octet = "";
		for(int i=0; i< table.length;i++){
			temp = Integer.parseInt(table[i],16);
			if ((temp & 0x80) == 0x80) {
				octet = "0";
				if ((temp & 0x40) == 0x40)
					octet += "0";	
				else
					octet += "1";
				if ((temp & 0x20) == 0x20)
					octet += "0";	
				else
					octet += "1";
				if ((temp & 0x10) == 0x10)
					octet += "0";	
				else
					octet += "1";
				if ((temp & 0x08) == 0x08)
					octet += "0";	
				else
					octet += "1";
				if ((temp & 0x04) == 0x04)
					octet += "0";	
				else
					octet += "1";
				if ((temp & 0x02) == 0x02)
					octet += "0";	
				else
					octet += "1";
				if ((temp & 0x01) == 0x01)
					octet += "1";	
				else
					octet += "0";
				tableauByte[i] = (byte)(-Byte.parseByte(octet,2));
			}
			else
				tableauByte[i] = (byte)temp;
			System.out.println(tableauByte[i]);
 
		}
	}
 
}

[Lyra1606]

Merci beaucoup ludomacho, cela fonctionne parfaitement.
Effectivemment c'est pas super simple

[thelvin]

Il me semble, moi, qu'il y a plus simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public static byte[] hexaToBytes(String hexa) {
	// enlever les espaces
	hexa = hexa.replaceAll("\\s+", "");
	// que des paires de chiffres hexa : vérification
	if(!hexa.matches("([0-9a-fA-F]{2})+")) {
		throw new IllegalArgumentException("Invalid hexadecimal: [" + hexa + "]");
	}
 
	// En hexadécimal, deux lettres représentent un octet
	byte[] bytes = new byte[hexa.length()/2];
 
	for(int i = 0; i < bytes.length; i++) {
		// deux chiffres
		String byteString = hexa.substring(2*i, 2*i+2);
		// leur valeur dans un byte
		byte b = (byte)Integer.parseInt(byteString, 16);
		bytes[i] = b;
	}
	return bytes;
}
 
public static String bytesToHexa(byte[] bytes) {
	StringBuilder builder = new StringBuilder();
 
	for(byte b : bytes) {
		// transformer le byte en deux chiffres hexadécimaux
		String byteString = String.format("%02X ", b);
		builder.append(byteString);
	}
	return builder.toString();
}
 
public static void main(String... args) {
	byte bb = (byte)0xBB;
	String hexa = "BB BB BB";
 
	byte[] bytes = hexaToBytes(hexa);
	System.out.println("bytes[0] == 0xBB ? " + (bytes[0] == bb));
	System.out.println("Back to hexa: " + bytesToHexa(bytes));
}

Integer.parseInt(string, base) et String.format() sont quand même fort utiles pour faire le travail à notre place.

[Lyra1606]

Merci pour cette seconde solution

[ludomacho]

oui effectivement......