Convertion binaire /hexadécimal en java help

Salut,

Sans prétention, voici un exemple un peu bidouille ecrit à la "volée":

         String[] tabStr =
               {"00011000", "01101111", "11111111"};
         int valDec;
         int totValDec;
         String valHex;
         String resultHex;
         boolean encore = true;
         
         while(encore)
         {
            for (int iTab = 0; iTab < tabStr.length; iTab++)
            {
               valDec = 0;
               totValDec = 0;
               valHex = "";
               resultHex = "";
            // quartet gauche:
               for (int i = 0; i <4; i++)
               {
                  valDec = Integer.parseInt(tabStr[iTab].substring(i, i+1));
                  System.out.println("valdec = " + valDec);
                  if (i == 0)
                     totValDec+= valDec*8;
                  else
                     if (i == 1)
                        totValDec+= valDec*4;
                     else
                        if (i == 2)
                           totValDec+= valDec*2;
                        else
                           totValDec+= valDec*1;
               }
               System.out.println("totValdec = " + totValDec + "\n");
               valHex = Integer.toString(totValDec, 16);
               resultHex = valHex;
            
               totValDec = 0;
            // quartet droit:
               for (int i = 4; i <8; i++)
               {
                  valDec = Integer.parseInt(tabStr[iTab].substring(i, i+1));
                  System.out.println("valdec = " + valDec);
                  if (i == 4)
                     totValDec+= valDec*8;
                  else
                     if (i == 5)
                        totValDec+= valDec*4;
                     else
                        if (i == 6)
                           totValDec+= valDec*2;
                        else
                           totValDec+= valDec*1;
               }
               System.out.println("totValDec = " + totValDec);
               valHex = Integer.toString(totValDec, 16);
               resultHex+= valHex;
               System.out.println("resultHex = " + "\"" + resultHex + "\"" + "\n");
            }
            encore = false;
         }

Cordialement,

Dan

bonsoir !!!

merci pour ta réponse .

mais cela dit je n'ai pu exécuter ton code vu que je n'ai plus Jbuilder X sur mon pc car je viens de faire une réinstallation .

mon principe et que je convertis le nombre binaire en décimal aprés je dévise par 16 je sauvgarde le reste puis je fais une concaténation .

mais parcontre je n'ai aps trés bien compris le principe de ton code .

je vais essayer de réinstaller jbuilder là et voir ce que ça donne

merco

RE,

Je vais essayer de t'expliquer mon code.
Le principe est le suivant:

J'ai un tableau de Strings (tabStr) dans lequel je crée 3 bytes (octets).

Prenons le 1er byte "00011000" qui est composé de 2 quartets:

-Quartet de gauche "0001" est composé de 4 bits qui peuvent prendre les valeur 0 ou 1 (oui ou non).
Le 1er bit de ce quartet prend la valeur décimale 8 s'il est à 1 ou la valeur 0 s'il est à 0.
Le second bit prend la valeur 4 s'il est à 1 ou la valeur 0 s'il est à 0.
Le troisième 2 s'il est à 1 ou 0 s'il est à 0.
Et le quatrième et dernier 1 s'il est à 1 ou 0 s'il est à 0.

Reprenons notre quartet "0001":
Le 1er bit vaut 0, le 2ème vaut 0, le 3ème vaut 0 et le 4ème vaut 1.
Additionnons dans valDec les 4 valeurs: int valDec = 0 + 0 + 0 + 1 = 1 que l'on converti en hexa dans valHex:
String valHex = Integer.toString(ValDec, 16); soit la valeur hexa 1 que l'on range dans resultHex:
String resultHex = valHex; soit la valeur hexa 1

Passons au quartet de droite "1000":
Selons le même principe, le bit 1 vaut 8, le 2 vaut 0, le 3 vaut 0 et le 4 vaut 0 et 8 + 0 + 0 + 0 = 8 soit:
valDec = 8 que l'on converti en hexa dand valHex:
valHex = Integer.toString(ValDec, 16); soit la valeur hexa 8 que cette fois on vat concaténer dans resultHex:
resultHex+= valHex; soit resultHex = 18. C'est un String qui contient la valeur hexa 18 que l'on peut écrire
(18)16 18 base 16.

Mais comme le tableau tabStr est un tableau de Strings, pour extraire les "bits" j'utilise entre autres possibilités la méthode substring et je converti le String bit obtenu en int:
valDec = Integer.parseInt(tabStr[iTab].substring(i, i+1)); soit (0, 1) pour le 1er bit (1, 2) pour le 2ème etc...
Et en fait je n'additionne pas directement dans valDec mais dans totValDec:

Int totValDec+= valDec*8; pour le 1er bit (i = 0), si valDec = 1 on additionne 1*8 sinon 0*8
totValDec+= valDec*4; pour le 2èmer bit (i = 1), si valDec = 1 on additionne 1*4 sinon 0*4
totValDec+= valDec*2; pour le 3èmer bit (i = 2) si valDec = 1 on additionne 1*2 sinon 0*2 et
totValDec+= valDec*1; pour le 4èmer bit (i = 3) si valDec = 1 on additionne 1*1 sinon 0*1.

Remarque 1:

while(encore)
{
et
encore = false;
}
sont à supprimer même si çà fonctionne en les laissant: jétais parti sur une autre idée abandonnée...

Remarque 2:

Bien entendu, c'est du "brut de fonderie" çà peut se simplifier par exemple en mettant le traitement des 2 quartets dans la même boucle, et même poursuivre le traitement en ajoutant les 2ème et 3ème élements de tabStr à resultHex et obtenir (186FFF)16


Cordialement,

Dan

bonjour Dan !!!

merci beaucoup pour tes explications c'est super sympa de ta part .

je vais supprimer la condition du while et voir ce que ça donne .

très cordialement .

Bonjour,

Je suis vraiment désolé de t'avoir imposé tout ce code alors qu'on peut faire ceci;


int valDec = Integer.parseInt("00011000", 2); // conversion binaire -> décimal
System.out.println("valDec = " + valDec);
puis:
String valHex = Integer.toString(valDec, 16); // conversion décimal -> hexa
System.out.println("valHex = (" + valHexa+ ")16\n");

Ou bien en regroupant les 2 conversions:
valHex = Integer.toString(Integer.parseInt("00011000", 2), 16);
System.out.println("valHex = (" + valHex + ")16");

Pourquoi faire simple quand on peut faire compliqué???

Il reste à adapter la boucle de lecture du tableau:


//Conversion binaire/hexadécimal :
String[] tabStr =
{"00011000", "01101111", "11111111"}; // tableau de String de 3 bytes

String valHex;

for (int iTab = 0; iTab < tabStr.length; iTab++)
{
valHex = Integer.toString(Integer.parseInt(tabStr[iTab], 2), 16);
System.out.println("valeur hexa du byte " + (iTab +1) + " \"" + tabStr[iTab] + "\""
+ " = (" + valHex + ")16");
}

Et c'est tout!!!

Cordialement,

Dan

merci à toi !!!

au fait j'ai fais quelque modifications sur ton ancien code car il traité juste un exemple de 8 bits alors que moi je dois généraliser pour un quelconque nombre "plusieurs bits" .

je vais essayer d'exécuter ton code mais en tout cas t'as été trop sympa et je te remercie .

je t'ai laissé un messagae privé et j'aimerai avoir une réponse si c'est possible .

très cordialement.

bonsoir !!!!

au fait là j'ai programmé un graphe c'est comme un arbre au fait et là j'ai un souci c'est que les noeuds fils sont orientés quà droite et moi je veux que ça soit adroite et à gauche sachant que je peux déplacer ces noeuds là.

je ne sais pas quoi faire !!!!!

si vous avez une idée ça serait sympa .

merci