Convertir une chaîne hexadécimale en entier

J'essaie de convertir une chaîne de 8 caractères de code hexadécimal en un entier afin de pouvoir faire une comparaison int au lieu de comparaisons de chaînes sur un grand nombre de valeurs différentes.

Je sais que c'est assez trivial en C ++ mais je dois le faire en Java. Le cas de test que je dois satisfaire est essentiellement de convertir "AA0F245C" en int, puis de revenir à cette chaîne pour 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, ce que 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 juste pour que vous le sachiez, donc cela doit être fait dans les bibliothèques standard Java.

Merci d'avance pour votre aide.

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

Utilisation

Long.parseLong("AA0F245C", 16);

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);

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

Long.parseLong("AA0F245C", 16);

pour le faire fonctionner.

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

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

javadoc Integer

Voici la bonne réponse:

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

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

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

Une option supplémentaire à celles suggérées est d'utiliser la BigIntegerclasse. Comme les valeurs hexadécimales sont souvent de grands nombres, tels que les valeurs sha256 ou sha512, elles déborderont facilement de an intet a long. Bien que la conversion en tableau d'octets soit une option comme le montrent d'autres réponses BigInterger, la classe souvent oubliée en java est également une option.

String sha256 = "65f4b384672c2776116d8d6533c69d4b19d140ddec5c191ea4d2cfad7d025ca2";
BigInteger value = new BigInteger(sha256, 16);
System.out.println("value = " + value);
// 46115947372890196580627454674591875001875183744738980595815219240926424751266

//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);

Essayez avec ceci:

long abc = convertString2Hex ("1A2A3B");

private  long  convertString2Hex(String numberHexString)
{
    char[] ChaArray = numberHexString.toCharArray();
    long HexSum=0;
    long cChar =0;

    for(int i=0;i<numberHexString.length();i++ )
    {
        if( (ChaArray[i]>='0') && (ChaArray[i]<='9') )
            cChar = ChaArray[i] - '0';
        else
            cChar = ChaArray[i]-'A'+10;
        HexSum = 16 * HexSum + cChar;
    }
    return  HexSum;
}