Wie konvertiere ich ein Byte-Array in ein Long-Array in Java?

Byte-Array-zu-Long-Konvertierung in Java: Eine umfassende Anleitung

Die Konvertierung zwischen langen Datentypen und Byte-Arrays ist eine grundlegende Aufgabe in der Java-Programmierung , insbesondere wenn Daten über Netzwerke ausgetauscht oder in Binärformaten gespeichert werden. In diesem Artikel werden die verschiedenen Methoden zur effektiven Durchführung dieser Konvertierung beschrieben.

Konvertierung von Long- in Byte-Arrays

Um einen Long-Wert in ein Byte-Array zu konvertieren, können Sie Folgendes verwenden Ansatz:

<code class="java">public byte[] longToBytes(long x) {
    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
    buffer.putLong(x);
    return buffer.array();
}</code>

In diesem Code wird einem ByteBuffer-Objekt eine Größe zugewiesen, die der Anzahl der Bytes entspricht, die zur Darstellung eines langen Werts erforderlich sind. Die putLong-Methode wird verwendet, um den Long-Wert in den Puffer zu schreiben, und schließlich ruft die Array-Methode die zugrunde liegende Byte-Array-Darstellung ab.

Byte-Array in Long-Konvertierung

Um die umgekehrte Konvertierung durchzuführen, können Sie den folgenden Code verwenden:

<code class="java">public long bytesToLong(byte[] bytes) {
    ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
    buffer.put(bytes);
    buffer.flip(); // Flip the buffer to make it ready for reading
    return buffer.getLong();
}</code>

Hier wird erneut ein ByteBuffer-Objekt verwendet, dieses Mal um das bereitgestellte Byte-Array zu umschließen. Mit der Put-Methode werden die Bytes in den Puffer kopiert. Anschließend wird der Puffer umgedreht, um anzuzeigen, dass er nun zum Lesen bereit ist. Schließlich ruft die getLong-Methode den Long-Wert aus dem Puffer ab.

Vermeiden der wiederholten ByteBuffer-Erstellung

In Szenarien, in denen mehrere Konvertierungen durchgeführt werden, ist es effizienter, die Erstellung zu vermeiden neue ByteBuffer-Objekte für jede Konvertierung. Dies kann erreicht werden, indem der Prozess in eine Klasse eingeschlossen wird:

<code class="java">public class ByteUtils {
    private static ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);

    public static byte[] longToBytes(long x) {
        buffer.putLong(0, x);
        return buffer.array();
    }

    public static long bytesToLong(byte[] bytes) {
        buffer.put(bytes, 0, bytes.length);
        buffer.flip();
        return buffer.getLong();
    }
}</code>

In diesem Fall wird ein einzelnes ByteBuffer-Objekt für alle Konvertierungen gemeinsam genutzt, wodurch der Aufwand für die Objekterstellung minimiert wird.

Fazit

Die in diesem Artikel beschriebenen Methoden bieten effiziente und zuverlässige Möglichkeiten zur Konvertierung zwischen langen Werten und Byte-Arrays in Java. Unabhängig davon, ob Sie sich für den DirectByteBuffer-Ansatz entscheiden oder den ByteUtils-Wrapper verwenden, können Sie diese Konvertierungen in Ihren Anwendungen problemlos verarbeiten.

Das obige ist der detaillierte Inhalt vonWie konvertiere ich ein Byte-Array in ein Long-Array in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!