Java conversion de int en hex et de retour à nouveau

J'ai le code suivant...

int Val=-32768;
String Hex=Integer.toHexString(Val);

Cela équivaut à ffff8000

int FirstAttempt=Integer.parseInt(Hex,16); //Error "Invalid Int"
int SecondAttempt=Integer.decode("0x"+Hex);  //Error "Invalid Int"

Donc, d'abord, il convertit la valeur -32768 dans une chaîne hexadécimale de ffff8000, mais il ne peut pas convertir la chaîne hexadécimale de retour dans un Entier.

Dans .Net il fonctionne comme je m'attends, et returns -32768.

Je sais que je pourrais écrire ma propre petite méthode pour convertir moi-même, mais je me demande si je suis absent quelque chose, ou si c'est réellement un bug?

double possible de Java négatif int hex et à l'arrière échoue
Juste un conseil: en tant Que convention, les noms de variables commencent avec une minuscule: int firstAttempt = 5;

InformationsquelleAutor Rich S | 2012-08-17

42

Il déborde, parce que le nombre est négatif.

Essayer ceci et cela fonctionne:
```
int n = (int) Long.parseLong("ffff8000", 16);
```
- Merci roni, qui semble être la meilleure solution. Bien qu'il semble étrange que Int.parseInt ne fonctionne pas comme je l'avais espérer.
- ffff8000 ne rentre pas dans un int (plus grand que max int), c'est un nombre positif (c'est une chaîne donc négatif que si elle a moins)
- C'est parce que parseInt prend signé int et toHexString produit un entier non signé (voir ma réponse)...
- Merci u a sauvé ma journée 🙂
- que faire si l'hex est de la Chaîne de valeur comme String Hex=Integer.toHexString("xyz"); comment obtenir le dos de la chaîne de l'hexagone "xyz"
InformationsquelleAutor roni
61
```
int val = -32768;
String hex = Integer.toHexString(val);

int parsedResult = (int) Long.parseLong(hex, 16);
System.out.println(parsedResult);
```
C'est comment vous pouvez le faire.

La raison pour laquelle il n'est pas de travailler votre chemin: Integer.parseInt prend un signé de type int, alors que toHexString produit un unsigned résultat. Donc, si vous insérez quelque chose de plus élevé que 0x7FFFFFF, une erreur sera générée automatiquement. Si vous l'analyser comme long au lieu de cela, il sera encore signé. Mais quand vous le lancez de retour de type int, il va de dépassement de la valeur correcte.

InformationsquelleAutor brimborium
19
- int Hex :
```
Integer.toHexString(intValue);
```
- Hex à int :
```
Integer.valueOf(hexString, 16).intValue();
```
Vous pouvez également utiliser long au lieu de int (si la valeur ne correspond pas à la int de limites):
- Hex à long:
```
Long.valueOf(hexString, 16).longValue()
```
- long Hex
```
Long.toHexString(longValue)
```
InformationsquelleAutor
8

Il vaut la peine de mentionner que Java 8 a les méthodes Integer.parseUnsignedInt et Long.parseUnsignedLong qui fait ce que vous vouliez, en particulier:

Integer.parseUnsignedInt("ffff8000",16) == -32768

Le nom est un peu déroutant, car il traite un entier signé à partir d'une chaîne hexadécimale, mais il fait le travail.

InformationsquelleAutor Yuval Sapir

Essayez d'utiliser BigInteger classe, il fonctionne.

int Val=-32768;
String Hex=Integer.toHexString(Val);

//int FirstAttempt=Integer.parseInt(Hex,16); //Error "Invalid Int"
//int SecondAttempt=Integer.decode("0x"+Hex);  //Error "Invalid Int"
BigInteger i = new BigInteger(Hex,16);
System.out.println(i.intValue());

InformationsquelleAutor maneesh

3

Comme Un Entier.toHexString(byte/entier) ne fonctionne pas lorsque vous tentez de convertir signé octets comme UTF-16 décodé caractères que vous avez à utiliser:
```
Integer.toString(byte/integer, 16);
```
ou
```
String.format("%02X", byte/integer);
```
inverse vous pouvez utiliser
```
Integer.parseInt(hexString, 16);
```
InformationsquelleAutor Spektakulatius

Java de la méthode parseInt est actally un tas de code de manger des "faux" hex : si vous voulez traduire -32768, vous devez convertir la valeur absolue en hexadécimal, puis ajouter la chaîne par un '-'.

Il est un exemple de Integer.java fichier :

public static int parseInt(String s, int radix)

La description est tout à fait explicite :

* Parses the string argument as a signed integer in the radix 
* specified by the second argument. The characters in the string 
...
...
* parseInt("0", 10) returns 0
* parseInt("473", 10) returns 473
* parseInt("-0", 10) returns 0
* parseInt("-FF", 16) returns -255

InformationsquelleAutor Benj

À l'aide de Integer.toHexString(...) est une bonne réponse. Mais personnellement, préférez utiliser String.format(...).

Essayez cet exemple comme un test.

byte[] values = new byte[64];
Arrays.fill(values, (byte)8);  //Fills array with 8 just for test
String valuesStr = "";
for(int i = 0; i < values.length; i++)
    valuesStr += String.format("0x%02x", values[i] & 0xff) + " ";
valuesStr.trim();

InformationsquelleAutor Chef Pharaoh

1

Hehe, curieux. Je pense que c'est un "intentianal bug", pour ainsi dire.

La raison sous-jacente est de savoir comment la classe Integer est écrit. Fondamentalement, parseInt est "optimisé" pour les nombres positifs. Lorsqu'il analyse la chaîne de caractères, il construit le résultat de façon cumulative, mais niée. Puis il retourne le signe du résultat final.

Exemple:

66 = 0x42

analysée comme:
```
4*(-1) = -4
-4 * 16 = -64 (hex 4 parsed)

-64 - 2 = -66 (hex 2 parsed)

return -66 * (-1) = 66
```
Maintenant, passons à votre exemple
FFFF8000
```
16*(-1) = -16 (first F parsed)
-16*16 = -256 

-256 - 16 = -272 (second F parsed)
-272 * 16 = -4352 

-4352 - 16 = -4368 (third F parsed)
-4352 * 16 = -69888

-69888 - 16 = -69904 (forth F parsed)
-69904 * 16 = -1118464 

-1118464 - 8 = -1118472 (8 parsed)
-1118464 * 16 = -17895552 

-17895552 - 0 = -17895552 (first 0 parsed)
Here it blows up since -17895552 < -Integer.MAX_VALUE / 16 (-134217728). 
Attempting to execute the next logical step in the chain (-17895552 * 16)
would cause an integer overflow error.
```
Modifier (ajout): pour que le parseInt() pour travailler "régulièrement" pour -Entier.MAX_VALUE <= n <= Integer.MAX_VALUE, ils auraient dû mettre en œuvre une logique de "faire tourner" lors de l'atteinte d'un Entier.MAX_VALUE dans le résultat cumulatif, à partir de plus de au max à la fin de l'intervalle entier et continuer vers le bas à partir de là. Pourquoi ils ne l'ont pas fait, on aurait du demander à Josh Bloch ou celui qui l'a mise en œuvre en premier lieu. C'est peut-être une optimisation.

Cependant,
```
Hex=Integer.toHexString(Integer.MAX_VALUE);
System.out.println(Hex);
System.out.println(Integer.parseInt(Hex.toUpperCase(), 16));
```
fonctionne bien, justement pour cette raison. Dans le sourcee pour Entier, vous pouvez trouver ce commentaire.
```
//Accumulating negatively avoids surprises near MAX_VALUE
```
- // Accumulating negatively avoids surprises near MAX_VALUE ->, mais il introduit des surprises inférieure à 0 ^^
InformationsquelleAutor pap

Code ci-dessous devrait fonctionner:

int a=-32768;
String a1=Integer.toHexString(a);
int parsedResult=(int)Long.parseLong(a1,16);
System.out.println("Parsed Value is " +parsedResult);

InformationsquelleAutor user7258708

Vous devez vous connecter pour publier un commentaire.