it-swarm.com.de

Konvertierung von Little Endian in Big Endian

Alles,

Ich habe Online-Codierungsprobleme geübt. Zur Zeit arbeite ich an einer Problemaussage Probleme wo wir Big Endian <-> Little Endian konvertieren müssen. Aber ich kann die Schritte nicht notieren, wenn man das gegebene Beispiel betrachtet: 

123456789 converts to 365779719

Die Logik, die ich erwäge, ist:
1> Den ganzzahligen Wert abrufen (Da ich unter Windows x86 bin, lautet die Eingabe Little endian)
2> Erzeugen Sie die Hex-Darstellung derselben.
3> Kehren Sie die Darstellung um und generieren Sie den ganzzahligen Big-Endian-Wert 

Aber ich vermisse hier offensichtlich etwas. 

Kann jemand mich bitte führen. Ich codiere in Java 1.5

16
name_masked

Sie müssen wissen, dass Endian-Swaps die Bytes behandeln, die die ganze Zahl darstellen. Die 4-Byte-Nummer 27 sieht also aus wie 0x0000001B. Um diese Zahl zu konvertieren, muss sie zu 0x1B000000... wechseln. In Ihrem Beispiel lautet die Hex-Darstellung von 123456789 0x075BCD15, die zu 0x15CD5B07 oder in dezimaler Form 365779719 gehen muss.

Die Funktion Stacker posted verschiebt diese Bytes durch Bitverschiebung; Genauer gesagt, die Anweisung i&0xff nimmt das niedrigste byte von i, der << 24 schiebt es dann um 24 Bits nach oben, also von Position 1-8 auf 25-32. Also weiter durch jeden Teil des Ausdrucks.

Sehen Sie sich zum Beispiel Code an this .

21
Bryan

Da ein großer Teil der Schreibsoftware auf die Wiederverwendung vorhandener Lösungen abzielt, sollten Sie zunächst immer einen Blick in die Dokumentation Ihrer Sprache/Bibliothek werfen.

reverse = Integer.reverseBytes(x);

Ich weiß nicht, wie effizient diese Funktion ist, aber um viele Zahlen umzuschalten, sollte eine ByteBuffer eine anständige Leistung bieten.

import Java.nio.ByteBuffer;
import Java.nio.ByteOrder;

...

int[] myArray = aFountOfIntegers();
ByteBuffer buffer = ByteBuffer.allocate(myArray.length*Integer.BYTES);

buffer.order(ByteOrder.LITTLE_ENDIAN);
for (int x:myArray) buffer.putInt(x);

buffer.order(ByteOrder.BIG_ENDIAN);
buffer.rewind();
int i=0;
for (int x:myArray) myArray[i++] = buffer.getInt(x);

Wie eversor in den Kommentaren darauf hingewiesen hat, ist ByteBuffer.putInt() eine optionale Methode und möglicherweise nicht für alle Java-Implementierungen verfügbar.

Der DIY-Ansatz

Stackers Antwort ist ziemlich ordentlich, aber es ist möglich, sie zu verbessern. 

   reversed = (i&0xff)<<24 | (i&0xff00)<<8 | (i&0xff0000)>>8 | (i>>24)&0xff;

Wir können die Klammern loswerden, indem wir die Bitmasken anpassen. Zum Beispiel ist (a & 0xFF)<<8 äquivalent zu a<<8 & 0xFF00. Die Klammern ganz rechts waren sowieso nicht notwendig.

   reversed = i<<24 & 0xff000000 | i<<8 & 0xff0000 | i>>8 & 0xff00 | i>>24 & 0xff;

Da sich die Verschiebung nach links um null Bits verschiebt, ist die erste Maske redundant. Wir können die Maske ganz rechts entfernen, indem Sie den logischen Verschiebungsoperator verwenden, der nur um null Bits verschiebt.

   reversed = i<<24 | i>>8 & 0xff00 | i<<8 & 0xff0000 | i>>>24;

Operator-Vorrang Hier finden Sie die groben Details zu Schichtoperatoren in der Java-Sprachspezifikation

26
Wolfram Schmied

Schau dir das an 

int little2big(int i) {
    return (i&0xff)<<24 | (i&0xff00)<<8 | (i&0xff0000)>>8 | (i>>24)&0xff;
}
25
stacker

Java-Primitiv-Wrapper-Klassen unterstützen die Byte-Umkehrung seit 1.5 mit der reverseBytes-Methode.

Short.reverseBytes(short i)
Integer.reverseBytes(int i)
Long.reverseBytes(long i)

Nur ein Beitrag für diejenigen, die diese Antwort 2018 suchen.

5
glf4k

die folgende Methode kehrt die Reihenfolge der Bits in einem Byte-Wert um:

public static byte reverseBitOrder(byte b) {
    int converted = 0x00;
    converted ^= (b & 0b1000_0000) >> 7;
    converted ^= (b & 0b0100_0000) >> 5;
    converted ^= (b & 0b0010_0000) >> 3;
    converted ^= (b & 0b0001_0000) >> 1;
    converted ^= (b & 0b0000_1000) << 1;
    converted ^= (b & 0b0000_0100) << 3;
    converted ^= (b & 0b0000_0010) << 5;
    converted ^= (b & 0b0000_0001) << 7;

    return (byte) (converted & 0xFF);
}
0
Lukas Z.

Ich denke, das kann auch helfen:

int littleToBig(int i)
{
    int b0,b1,b2,b3;

    b0 = (i&0x000000ff)>>0;
    b1 = (i&0x0000ff00)>>8;
    b2 = (i&0x00ff0000)>>16;
    b3 = (i&0xff000000)>>24;

    return ((b0<<24)|(b1<<16)|(b2<<8)|(b3<<0));
}
0
Venu