Discussion :

[boboss123]

bonjour,

J'ai une variable de type Long qui contient une adresse MAC (nombre compris entre 0x000000000000 et 0xFFFFFFFFFFFF)

Comment faire pour convertir ce nombre en une chaine de caractère de cette forme : xx : xx : xx : xx : xx : xx
=> xx représente la décomposition en valeurs hexadécimales de l'adresse MAC

ex:
Si ma variable vaut 0x010203040506
=> je veux avoir la chaine de caractère "01:02:03:04:05:06"


aussi, lorsque je fais ça :

Code :

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

Long val = Long.parseLong(varStr, 16); // convertion en nombre

=> si la chaine n'est pas un nombre ça me génère une erreur : comment faire pour éviter ceci ?


merci d'avance

[tchize_]

Comment faire pour convertir ce nombre en une chaine de caractère de cette forme : xx : xx : xx : xx : xx : xx

A la main, tu décompose en bytes ton long et tu affiche chaque byte séparément en hexadécimal

aussi, lorsque je fais ça :

Code :

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

Long val = Long.parseLong(varStr, 16); // convertion en nombre

=> si la chaine n'est pas un nombre ça me génère une erreur : comment faire pour éviter ceci ?

Si tu veux dire "comment parser une adresse mac", encore un fois c'est à la main. Tu splitte autour des ":" ta chaine, et pour chaque élément du split, tu fait passer dans Integer.parseInt(element,16) pour faire du parsing en hexadécimal.

[boboss123]

ok merci, je pensais qu'il y avait des fonctions toutes faite pour ça

Pour parser un long en byte[], on fait comment (la classe Byte ne sait parser que des String) ?

aussi, lorsque je fais ça :
Code :

Long val = Long.parseLong(varStr, 16); // convertion en nombre

=> si la chaine n'est pas un nombre ça me génère une erreur : comment faire pour éviter ceci ?

Si tu veux dire "comment parser une adresse mac", encore un fois c'est à la main. Tu splitte autour des ":" ta chaine, et pour chaque élément du split, tu fait passer dans Integer.parseInt(element,16) pour faire du parsing en hexadécimal.

non, ce que je voudrais faire c'est tester si element peut etre parser en int avant d'utiliser la focntion (pour eviter d'avoir une erreur)

[tchize_]

Pour parser un long en byte[], on fait comment (la classe Byte ne sait parser que des String) ?

pas parser, convertir. Suffit d'extraire les bits qui t'intéressent:

Code :

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

1
2
3
byte0 = addresseLong & 0XFF;
byte1 = addresseLong & 0XFF00 >> 8;
byte2 = addresseLong & 0XFF0000 >> 16;

Etc...

non, ce que je voudrais faire c'est tester si element peut etre parser en int avant d'utiliser la focntion (pour eviter d'avoir une erreur)

Avec un expression régulière, par exemple:

Code :

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

adressesString.matches("^\\s*(\\p{XDigit}\\p{XDigit}:){5}\\p{XDigit}\\p{XDigit}\\s*$");

[boboss123]

Ok, merci beaucoup

pas parser, convertir. Suffit d'extraire les bits qui t'intéressent:

Code :

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

1
2
3
byte0 = addresseLong & 0XFF;
byte1 = addresseLong & 0XFF00 >> 8;
byte2 = addresseLong & 0XFF0000 >> 16;

=> c'est super lourd tous ces décalages et ces masques, y a pas plus simple ? En langage C ça aurait donné juste ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
char myByte[4];
long myVal = 0x123456; // (taille 8 bytes en C)
myByte[0] = ((char*)&myVal )[0];
myByte[1] = ((char*)&myVal )[1];
myByte[2] = ((char*)&myVal )[2];
myByte[3] = ((char*)&myVal )[3];
 
 
// ou encore
*((long*)myByte) = myVal;

[tchize_]

non, d'abord ton code C est faux, un long ne fait pas nécessairement 8 byte en C, sa taille minimum est de 32bits, mais ca peut varier suivant l'architecture et le compilateur utilisé. C

Ensuite, plus grave, ton code présuppose que les bytes au sein d'un long sont dans une endiance précise, ce qui n'est pas garantit suivant l'architecture utilisée. Dans ton cas, si j'exécute ton code sur x86, j'obtiens "56 34 12", sur HP-UX/PA-RISC j'obtiens "0 12 34". A contrario, un code avec des masque donne la garantie que c'est toujours le meme résultat.


Finalement, ce code détourne l'arithmétique sur les pointeur, il n'y a pas de pointeur en java.

Si tu veux faire "plus court", t'as ce code ci

Code :

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

1
2
3
4
byte[] b = new byte[8];
long val = ....;
for (int i = 0; i< 8; i++)
   b[i]=val&(0xFF<<(i*8))>>i*8

mais c'est moins lisible et moins performant.

[thelvin]

En fait

Code :

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

1
2
3
4
byte[] b = new byte[8];
long val = ....;
for (int i = 0; i< 8; i++)
   b[i]= (byte)(val >> i*8);

Est suffisant. Un byte ne contient que 8 bits de toutes façon. Pas besoin de masque, le cast n'a pas vraiment le choix.

[adiGuba]

Salut,


J'arrive un peu tard sur le sujet... mais il s'agit de simple conversion et il me semble que vous vous compliquer un peu la vie.

Depuis Java 5 on dispose de la méthode String.format() qui permet de formater des chaines "à la printf" ce qui est très pratique également pour formater un nombre en une base quelconque.

Cela permet en particulier de définir une longueur minimum pour la valeur, en rajoutant automatiquement les zéro inutile :

Code :

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

1
2
3
4
long number = 0x010203040506L;
 
// Convertion number -> text
String text = String.format("%012X", number); // renvoi : "010203040506"

Ensuite il suffit de rajouter les ":" tous les 2 caractères, ce qui nous donne via une expression régulière :

Code :

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

1
2
3
4
5
long number = 0x010203040506L;
 
// Convertion number -> text
String text = String.format("%012X", number)
	.replaceAll("(..)(?!$)", "$1:"); // renvoi "01:02:03:04:05:06"

Enfin, pour la conversion inverse ("01:02:03:04:05:06" vers un long), il suffit de "supprimer" les ":" afin de pouvoir parser la valeur tout à fait normalement :

Code :

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

1
2
// Conversion text -> number
number = Long.parseLong( text.replace(":", ""), 16 );

Et on ne s'embête pas avec des décalages de bits

non, ce que je voudrais faire c'est tester si element peut etre parser en int avant d'utiliser la focntion (pour eviter d'avoir une erreur)

Attention à ceci car c'est bien souvent un mauvais choix car cela revient à doubler les traitements. La meilleur façon de s'assurer que parseLong() ne génère pas d'erreur serait d'appeler parseLong()

Toutes les autres solutions ne sont pas forcément sûr (en particulier à causes des plages de valeurs possibles) et ne font que rajouter du code inutile dans 95% des cas.

Il est nettement plus simple de traiter l'erreur lorsqu'elle surgit plutôt que de tenter de la repérer en amont...


a++