Konvertieren Sie eine Hex-Zeichenfolge in int

Ich versuche, eine Zeichenfolge mit 8 Zeichen Hex-Code in eine Ganzzahl umzuwandeln, damit ich einen Int-Vergleich anstelle von Zeichenfolgenvergleichen über viele verschiedene Werte durchführen kann.

Ich weiß, dass dies in C ++ ziemlich trivial ist, aber ich muss es in Java tun. Der Testfall, den ich erfüllen muss, besteht im Wesentlichen darin, "AA0F245C" in int und dann zurück in diesen String zu konvertieren, damit ich weiß, dass er richtig konvertiert.

Ich habe folgendes versucht:

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

Ich habe auch versucht, zwei Zeichen gleichzeitig zu machen und die Ergebnisse zu multiplizieren, was bei der Konvertierung funktioniert, aber die Zahl stimmt nicht.

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. 

Ich kann keine Bibliotheken von Drittanbietern verwenden, nur damit Sie wissen, dass dies in Java-Standardbibliotheken erfolgen muss.

Danke im Voraus für Ihre Hilfe.

Es ist einfach zu groß für ein int (das 4 Bytes ist und signiert).

Verwenden

Long.parseLong("AA0F245C", 16);

Sie können so verwenden

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

Der maximale Wert, den ein Java verarbeiten Integerkann, ist 2147483657 oder 2 ^ 31-1. Die Hexadezimalzahl AA0F245C ist 2853119068 als Dezimalzahl und viel zu groß, sodass Sie sie verwenden müssen

Long.parseLong("AA0F245C", 16);

damit es funktioniert.

Sie können dies einfach mit parseInt mit dem Formatparameter tun.

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

Javadoc Integer

Das ist die richtige Antwort:

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

Für diejenigen unter Ihnen, die die hexadezimale Darstellung eines vorzeichenbehafteten Bytes aus einem zweistelligen String in ein Byte konvertieren müssen (das in Java immer signiert ist), gibt es ein Beispiel. Das Parsen einer hexadezimalen Zeichenfolge ergibt niemals eine negative Zahl, was fehlerhaft ist, da 0xFF unter bestimmten Gesichtspunkten -1 ist (Zweierkomplementcodierung). Das Prinzip besteht darin, den eingehenden String als int zu analysieren, das größer als das Byte ist, und dann negative Zahlen zu umbrechen. Ich zeige nur Bytes, daher ist dieses Beispiel kurz genug.

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

Dies kann bearbeitet werden, um längere Nummern zu verarbeiten. Fügen Sie einfach weitere FFs bzw. 00s hinzu. Zum Parsen von 8 Ganzzahlen mit Hex-Zeichen müssen Sie Long.parseLong verwenden, da FFFF-FFFF (Ganzzahl -1) nicht in Integer passt, wenn es als positive Zahl dargestellt wird (ergibt 4294967295). Sie brauchen also Long, um es zu speichern. Nach der Konvertierung in eine negative Zahl und dem Zurücksetzen in eine Ganzzahl passt es. Es gibt keine 8-stellige Hex-Zeichenfolge, die am Ende nicht in eine Ganzzahl passt.

Eine zusätzliche Option zu den vorgeschlagenen ist die Verwendung der BigIntegerKlasse. Da Hex-Werte häufig große Zahlen sind, wie z. B. sha256- oder sha512-Werte, können sie leicht an intund a überlaufen long. Während die Konvertierung in ein Byte-Array eine Option ist, wie andere Antworten zeigen, BigIntergerist die häufig vergessene Klasse in Java ebenfalls eine 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);

Versuchen Sie es damit:

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