Konvertieren Sie ein Byte-Array in Java in eine Ganzzahl und umgekehrt

Ich möchte einige Daten in Byte-Arrays in Java speichern. Grundsätzlich nur Zahlen, die bis zu 2 Bytes pro Zahl aufnehmen können.

Ich möchte wissen, wie ich eine Ganzzahl in ein 2 Byte langes Byte-Array konvertieren kann und umgekehrt. Ich habe viele Lösungen gefunden, die googeln, aber die meisten erklären nicht, was im Code passiert. Es gibt viele wechselnde Dinge, die ich nicht wirklich verstehe, daher würde ich mich über eine grundlegende Erklärung freuen.

Verwenden Sie die im java.nioNamespace gefundenen Klassen , insbesondere die ByteBuffer. Es kann die ganze Arbeit für Sie erledigen.

byte[] arr = { 0x00, 0x01 };
ByteBuffer wrapped = ByteBuffer.wrap(arr); // big-endian by default
short num = wrapped.getShort(); // 1

ByteBuffer dbuf = ByteBuffer.allocate(2);
dbuf.putShort(num);
byte[] bytes = dbuf.array(); // { 0, 1 }

byte[] toByteArray(int value) {
     return  ByteBuffer.allocate(4).putInt(value).array();
}

byte[] toByteArray(int value) {
    return new byte[] { 
        (byte)(value >> 24),
        (byte)(value >> 16),
        (byte)(value >> 8),
        (byte)value };
}

int fromByteArray(byte[] bytes) {
     return ByteBuffer.wrap(bytes).getInt();
}
// packing an array of 4 bytes to an int, big endian, minimal parentheses
// operator precedence: <<, &, | 
// when operators of equal precedence (here bitwise OR) appear in the same expression, they are evaluated from left to right
int fromByteArray(byte[] bytes) {
     return bytes[0] << 24 | (bytes[1] & 0xFF) << 16 | (bytes[2] & 0xFF) << 8 | (bytes[3] & 0xFF);
}

// packing an array of 4 bytes to an int, big endian, clean code
int fromByteArray(byte[] bytes) {
     return ((bytes[0] & 0xFF) << 24) | 
            ((bytes[1] & 0xFF) << 16) | 
            ((bytes[2] & 0xFF) << 8 ) | 
            ((bytes[3] & 0xFF) << 0 );
}

Beim Packen von vorzeichenbehafteten Bytes in ein int muss jedes Byte maskiert werden, da es aufgrund der arithmetischen Heraufstufungsregel (beschrieben in JLS, Conversions and Promotions) auf 32 Bit vorzeichenerweitert (anstatt auf null erweitert) ist.

Es gibt ein interessantes Puzzle, das in Java Puzzlers ("Eine große Freude in jedem Byte") von Joshua Bloch und Neal Gafter beschrieben ist. Beim Vergleichen eines Bytewerts mit einem int-Wert wird das Byte vorzeichenerweitert zu einem int und dieser Wert wird dann mit dem anderen int verglichen

byte[] bytes = (…)
if (bytes[0] == 0xFF) {
   // dead code, bytes[0] is in the range [-128,127] and thus never equal to 255
}

Beachten Sie, dass alle numerischen Typen in Java signiert sind, mit Ausnahme von char, einem 16-Bit-Integer-Typ ohne Vorzeichen.

Sie können BigInteger auch für Bytes variabler Länge verwenden. Sie können es in long, int oder short konvertieren, je nachdem, was Ihren Anforderungen entspricht.

new BigInteger(bytes).intValue();

oder um die Polarität zu bezeichnen:

new BigInteger(1, bytes).intValue();

Um Bytes zurückzubekommen, einfach:

new BigInteger(bytes).toByteArray()

Eine grundlegende Implementierung wäre ungefähr so:

public class Test {
    public static void main(String[] args) {
        int[] input = new int[] { 0x1234, 0x5678, 0x9abc };
        byte[] output = new byte[input.length * 2];

        for (int i = 0, j = 0; i < input.length; i++, j+=2) {
            output[j] = (byte)(input[i] & 0xff);
            output[j+1] = (byte)((input[i] >> 8) & 0xff);
        }

        for (int i = 0; i < output.length; i++)
            System.out.format("%02x\n",output[i]);
    }
}

Um die Dinge zu verstehen, können Sie diesen WP-Artikel lesen: http://en.wikipedia.org/wiki/Endianness

Der obige Quellcode wird ausgegeben 34 12 78 56 bc 9a. Die ersten 2 Bytes ( 34 12) stellen die erste Ganzzahl usw. dar. Der obige Quellcode codiert Ganzzahlen im Little-Endian-Format.

/** length should be less than 4 (for int) **/
public long byteToInt(byte[] bytes, int length) {
        int val = 0;
        if(length>4) throw new RuntimeException("Too big to fit in int");
        for (int i = 0; i < length; i++) {
            val=val<<8;
            val=val|(bytes[i] & 0xFF);
        }
        return val;
    }

Jemand mit einer Anforderung, bei der er aus Bits lesen muss, sagen wir, Sie müssen nur aus 3 Bits lesen, aber Sie benötigen eine vorzeichenbehaftete Ganzzahl und verwenden dann Folgendes:

data is of type: java.util.BitSet

new BigInteger(data.toByteArray).intValue() << 32 - 3 >> 32 - 3

Die magische Zahl 3kann durch die Anzahl der von Ihnen verwendeten Bits (nicht Bytes) ersetzt werden.

Wie so oft hat Guave das, was Sie brauchen.

Um vom Byte-Array zu int: zu wechseln Ints.fromBytesArray, dokumentieren Sie hier

Um von int zu Byte Array zu wechseln : Ints.toByteArray, doc hier

Ich denke, dies ist der beste Modus, um auf int zu übertragen

   public int ByteToint(Byte B){
        String comb;
        int out=0;
        comb=B+"";
        salida= Integer.parseInt(comb);
        out=out+128;
        return out;
    }

erstes Byte in String konvertieren

comb=B+"";

Der nächste Schritt ist das Konvertieren in ein Int

out= Integer.parseInt(comb);

aber Byte ist in Wut von -128 bis 127 für diesen Grund, ich denke, ist besser, Wut 0 bis 255 zu verwenden, und Sie müssen nur dies tun:

out=out+256;