web-dev-qa-db-fra.com

Convertit une chaîne hexagonale en int

J'essaie de convertir une chaîne de 8 caractères de code hexadécimal en un entier afin de pouvoir effectuer une comparaison int à la place de comparaisons de chaînes sur de nombreuses valeurs différentes.

Je sais que c'est assez trivial en C++, mais je dois le faire en Java. Le scénario de test que je dois satisfaire consiste essentiellement à convertir "AA0F245C" en int, puis à revenir à cette chaîne afin que je sache que la conversion est correcte.

J'ai essayé ce qui suit:

int decode = Integer.decode("0xAA0F245C");  // NumberFormatException
int decode2 = Integer.decode("AA0F245C"); //NumberFormatException
int parseInt = Integer.parseInt("AA0F245C", 16); //NumberFormatException
int valueOf = Integer.valueOf("AA0F245C", 16); //NumberFormatException

J'ai également essayé de le faire deux caractères à la fois et de multiplier les résultats. La conversion fonctionne, mais le nombre n'est pas correct.

int id = 0;
for (int h = 0; h < hex.length(); h= h+2)
{
    String sub = hex.subSequence(h, h+2).toString();

if (id == 0)
    id = Integer.valueOf(sub, 16);
else
    id *= Integer.valueOf(sub, 16);             
 }
//ID = 8445600 which = 80DEA0 if I convert it back.

Je ne peux pas utiliser de bibliothèques tierces uniquement pour que vous sachiez que cela doit être fait dans les bibliothèques standard Java.

Merci d'avance pour votre aide.

javahex
99
Roloc

C'est simplement trop grand pour un int (qui est 4 octets et signé).

Utilisation

Long.parseLong("AA0F245C", 16);
137
Denys Séguret

vous pouvez utiliser comme ça

System.out.println(Integer.decode("0x4d2"))    // output 1234
//and vice versa 
System.out.println(Integer.toHexString(1234); //  output is 4d2);
28
manikant gautam

La valeur maximale qu'un Java Integer peut gérer est 2147483657 ou 2 ^ 31-1. Le nombre hexadécimal AA0F245C est 2853119068 comme nombre décimal et est beaucoup trop grand, vous devez donc utiliser

Long.parseLong("AA0F245C", 16);

pour le faire fonctionner.

16
Incompl

vous pouvez facilement le faire avec parseInt avec le paramètre format.

Integer.parseInt("-FF", 16) ; // returns -255

javadoc Integer

6
heat

C'est la bonne réponse:

myPassedColor = "#ffff8c85" int colorInt = Color.parseColor(myPassedColor)

5
Hannah Louisa Carney

Pour ceux d'entre vous qui ont besoin de convertir la représentation hexadécimale d'un octet signé de chaîne de deux caractères en octet (qui, dans Java est toujours signée), voici un exemple. L'analyse d'une chaîne hexadécimale ne donne jamais un nombre négatif, ce qui est erroné, car 0xFF est -1 d'un certain point de vue (codage du complément à deux). Le principe consiste à analyser la chaîne entrante en tant que int, ce qui est plus grand qu'un octet, puis en entourant les nombres négatifs. Je ne montre que des octets, cet exemple est donc assez court.

String inputTwoCharHex="FE"; //whatever your microcontroller data is

int i=Integer.parseInt(inputTwoCharHex,16);
//negative numbers is i now look like 128...255

// shortly i>=128
if (i>=Integer.parseInt("80",16)){

    //need to wrap-around negative numbers
    //we know that FF is 255 which is -1
    //and FE is 254 which is -2 and so on
    i=-1-Integer.parseInt("FF",16)+i;
    //shortly i=-256+i;
}
byte b=(byte)i;
//b is now surely between -128 and +127

Ceci peut être édité pour traiter des nombres plus longs. Ajoutez simplement plus de FF ou de 00 respectivement. Pour analyser 8 entiers signés à caractères hexadécimaux, vous devez utiliser Long.parseLong, car FFFF-FFFF, qui est un entier -1, ne pourrait pas entrer dans Integer lorsqu'il est représenté sous la forme d'un nombre positif (donne 4294967295). Donc, vous avez besoin de Long pour le stocker. Après la conversion en nombre négatif et le retour à Integer, cela ira. Il n'y a pas de chaîne hexagonale de 8 caractères, qui ne correspondrait pas à un entier à la fin.

2
JanSmrz

Une option supplémentaire à celles suggérées consiste à utiliser la classe BigInteger. Étant donné que les valeurs hexadécimales sont souvent des nombres élevés, tels que sha256 ou sha512, elles débordent facilement d'un int et d'un long. La conversion en un tableau d'octets est une option comme le montrent d'autres réponses, mais BigInterger, la classe souvent oubliée en Java, l'est également.

String sha256 = "65f4b384672c2776116d8d6533c69d4b19d140ddec5c191ea4d2cfad7d025ca2";
BigInteger value = new BigInteger(sha256, 16);
System.out.println("value = " + value);
// 46115947372890196580627454674591875001875183744738980595815219240926424751266
0
Javaru
//Method for Smaller Number Range:
Integer.parseInt("abc",16);

//Method for Bigger Number Range.
Long.parseLong("abc",16);

//Method for Biggest Number Range.
new BigInteger("abc",16);
0
Nitish Kumar