Die Interpretation einer negativen Zahl als unsigned mit BigInteger

Ist es möglich zu analysieren, eine negative Zahl in eine vorzeichenlose Wert mit Java BigInteger?

Also zum Beispiel, ich würde interpretieren -1 als FFFFFFFFFFFFFFFF.

BigInteger hat unbegrenzte Länge. Auf welches Kriterium -1 wäre intepreted als FFFFFFFFFFFFFFFF statt, sagen, FFFFFFFF oder FF ?
warum brauchen Sie BigInteger? Long.toHexString(-1) = FFFFFFFFFFFFFFFF

InformationsquelleAutor One Two Three | 2012-06-04

Wenn Sie daran denken, ein Zweierkomplement ist, müssen Sie angeben, arbeiten die bit-Länge. Einen Java-long hat 64 bit, aber ein BigInteger ist nicht begrenzt.

Könnten Sie tun etwas wie dieses:

//Two's complement reference: 2^n . 
//In this case, 2^64 (so as to emulate a unsigned long)
private static final BigInteger TWO_COMPL_REF = BigInteger.ONE.shiftLeft(64);

public static BigInteger parseBigIntegerPositive(String num) {
    BigInteger b = new BigInteger(num);
    if (b.compareTo(BigInteger.ZERO) < 0)
        b = b.add(TWO_COMPL_REF);
    return b;
}

public static void main(String[] args) {
    System.out.println(parseBigIntegerPositive("-1").toString(16));
}

Aber dies würde implizit bedeuten, dass Sie die Arbeit mit BigIntegers in der 0 bis 2^64-1-Bereich.

Oder, mehr allgemein:

public static BigInteger parseBigIntegerPositive(String num,int bitlen) {
    BigInteger b = new BigInteger(num);
    if (b.compareTo(BigInteger.ZERO) < 0)
        b = b.add(BigInteger.ONE.shiftLeft(bitlen));
    return b;
}

Mehr fooproof, könnte man hinzufügen, einige Prüfungen, z.B.

public static BigInteger parseBigIntegerPositive(String num, int bitlen) {
    if (bitlen < 1)
        throw new RuntimeException("Bad bit length:" + bitlen);
    BigInteger bref = BigInteger.ONE.shiftLeft(bitlen);
    BigInteger b = new BigInteger(num);
    if (b.compareTo(BigInteger.ZERO) < 0)
        b = b.add(bref);
    if (b.compareTo(bref) >= 0 || b.compareTo(BigInteger.ZERO) < 0 )
        throw new RuntimeException("Out of range: " + num);
    return b;
}

Dies scheint problematisch zu sein in meinem Fall. Ich bin versucht zu Lesen unsigned int von 0xCCCCCCCC. Die BigInteger scheint gut, aber wenn ich rufe #toByteArray bekomme ich fünf bytes: CC CC CC CC 00. Irgendeine Idee warum?

InformationsquelleAutor leonbloy

6

Versuchen Sie es mit dem Konstruktor
```
public BigInteger(int signum, byte[] magnitude)
```
Der erste parameter sollte auf 1 gesetzt werden, um anzugeben, die Sie möchten, erstellen Sie eine positive Zahl ist. Das byte-array ist die Zahl, die Sie analysieren, in BIG-ENDIAN-REIHENFOLGE. Es sollte so interpretiert werden, eine Zahl ohne Vorzeichen, wenn Sie den ersten parameter auf 1. Der einzige trick ist immer Ihre Nummer in ein byte-array, aber das sollte nicht Biene zu schwierig.

EDIT: Sieht aus wie Sie haben zu tun, einige manuelle bit-Arithmetik hier. Wenn ich verstehe dein problem richtig, Sie müssen interpretiert einen String als Long und dann zu interpretieren, die lange als unsigned und speichern, die in der BigInteger-Klasse. Würde ich dies tun.
```
public BigInteger getValue(String numberString)
{
   Long longValue = Long.valueOf(numberString);
   byte [] numberAsArray = new byte[8];  
   for(int i = 0; i < 8; i++)
   {  
      numberAsArray[7 - i] = (byte)((longValue >>> (i * 8)) & 0xFF);
   }
   return new BigInteger(1, numberAsArray);
}  
```
Eigentlich, immer die Zahl in ein byte-array ist der springende Punkt. Ich bekomme eine numerische Zeichenfolge, und bat, Sie zu interpretieren als unsigned.
Ok, lassen Sie mich darüber nachdenken für eine Sekunde. Sie werden gegeben ein String-Objekt, und wollen, konvertieren Sie es in einen unsigned BigInteger? In diesem Fall, wissen Sie, wenn Ihr String-Objekt repräsentiert ein int oder ein long?
Wollte, um meine eigene Antwort... aber toByteArray() ist wahrscheinlich das, was Sie suchen.

InformationsquelleAutor Akron
1

Können Sie jederzeit manuell tun Zweierkomplement. Wenn die Zahl kleiner als 0 ist, dann inverse aller bits und addieren.

InformationsquelleAutor Gerhard Powell
1

One-Liner(aber nicht vergessen, zu prüfen, endiness Probleme mit der Quelle, die behandelt werden können mit ByteBuffer.byteOrder):
```
new BigInteger(1, ByteBuffer.allocate(Long.SIZE/Byte.SIZE).putLong(Long.parseLong("-1")).array());
```
InformationsquelleAutor LINEMAN78

Ist es, was Sie, was?

public static void main(String[] args) {

    BigInteger bg =  BigInteger.valueOf(-1);        
    System.out.println(Integer.toHexString(bg.intValue()));
}

schön, aber das Ergebnis ist: ffffffff 😉

InformationsquelleAutor Ahmet Karakaya

0

Können Sie dieses Dienstprogramm verwenden, zum konvertieren in eine Ganzzahl ohne Vorzeichen. Da BigIntegers haben unbegrenzte Größe, eine Größe muss angegeben werden, um zu bestimmen, wie viel Zeichen-Erweiterung zu halten, in der übersetzung:
```
public static BigInteger toPositive(BigInteger num, int sizeInBytes) {
    return num.andNot(BigInteger.valueOf(-1).shiftLeft(sizeInBytes * 8));
}
```
InformationsquelleAutor user3158036
0

Die einfache Lösung von @Ahmet Karakaya, sollte aber behoben werden, für größere zahlen:
```
BigInteger bg =  BigInteger.valueOf(-1);
System.out.println(Long.toHexString(bg.intValue()));
```
Ergebnis: ffffffffffffffff

oder einfach:
```
System.out.println(Long.toHexString(-1))
```
InformationsquelleAutor MariuszS

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.