Wie konvertiert man int[] in byte[]?

Question

Ich habe ein Array von Ganzzahlen, die ein RGB-Bild darstellen, und möchte es in ein Byte-Array umwandeln und in einer Datei speichern.

Wie konvertiert man in Java am besten ein Array von Ganzzahlen in ein Array von Bytes?

Answer 1

Als Brian sagt, müssen Sie herausfinden, welche Art von Umwandlung Sie benötigen.

Möchten Sie es als "normale" Bilddatei (jpg, png usw.) speichern?

Wenn ja, sollten Sie wahrscheinlich die Java Image I/O API.

Wenn Sie sie in einem "rohen" Format speichern wollen, müssen Sie die Reihenfolge angeben, in der die Bytes geschrieben werden sollen, und dann eine IntBuffer und NIO.

Ein Beispiel für die Verwendung einer ByteBuffer/IntBuffer-Kombination:

import java.nio.*;
import java.net.*;

class Test
{   
    public static void main(String [] args)
        throws Exception // Just for simplicity!
    {
        int[] data = { 100, 200, 300, 400 };

        ByteBuffer byteBuffer = ByteBuffer.allocate(data.length * 4);        
        IntBuffer intBuffer = byteBuffer.asIntBuffer();
        intBuffer.put(data);

        byte[] array = byteBuffer.array();

        for (int i=0; i < array.length; i++)
        {
            System.out.println(i + ": " + array[i]);
        }
    }
}

Answer 2

Verwenden Sie vielleicht diese Methode

byte[] integersToBytes(int[] values)
{
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   DataOutputStream dos = new DataOutputStream(baos);
   for(int i=0; i < values.length; ++i)
   {
        dos.writeInt(values[i]);
   }

   return baos.toByteArray();
}

Answer 3

Sie müssen zuerst entscheiden, wie Sie 1 Ganzzahl in eine Reihe von Bytes umwandeln.

Höchstwahrscheinlich (?) 1 Ganzzahl auf 4 Bytes, und verwenden Sie die Verschiebung ( >> ou << ) Operatoren, um jedes Byte herauszuholen (achten Sie auf die Byte-Reihenfolge!). Kopieren in ein Byte-Array, das 4 Mal so lang ist wie das Integer-Array.

Answer 4

Wenn Sie in eine Datei speichern wollen, sollten Sie vielleicht direkt in eine Datei speichern, indem Sie FileOutputStream.write verwenden:

    OutputStream os = new FileOutputStream("aa");
    int[] rgb = { 0xff, 0xff, 0xff };
    for (int c : rgb) {
        os.write(c);
    }
    os.close();

da es:

Schreibt das angegebene Byte in diesen Ausgabestrom. Der allgemeine Vertrag für write ist, dass ein Byte in den Ausgabestrom geschrieben wird. Das zu schreibende Byte sind die acht niederwertigen Bits des Arguments b. Die 24 höherwertigen Bits von b werden ignoriert.

Answer 5

Ich habe diesen Code erstellt und er funktioniert ziemlich gut:

    int IntToByte(byte arrayDst[], int arrayOrg[], int maxOrg){
        int i;
        int idxDst;
        int maxDst;
        //
        maxDst = maxOrg*4;
        //
        if (arrayDst==null)
            return 0;
        if (arrayOrg==null)
            return 0;
        if (arrayDst.length < maxDst)
            return 0;
        if (arrayOrg.length < maxOrg)
            return 0;
        //
        idxDst = 0;
        for (i=0; i<maxOrg; i++){
            // Copia o int, byte a byte.
            arrayDst[idxDst] = (byte)(arrayOrg[i]);
            idxDst++;
            arrayDst[idxDst] = (byte)(arrayOrg[i] >> 8);
            idxDst++;
            arrayDst[idxDst] = (byte)(arrayOrg[i] >> 16);
            idxDst++;
            arrayDst[idxDst] = (byte)(arrayOrg[i] >> 24);
            idxDst++;
        }
        //
        return idxDst;
    }

    int ByteToInt(int arrayDst[], byte arrayOrg[], int maxOrg){
        int i;
        int v;
        int idxOrg;
        int maxDst;
        //
        maxDst = maxOrg/4;
        //
        if (arrayDst==null)
            return 0;
        if (arrayOrg==null)
            return 0;
        if (arrayDst.length < maxDst)
            return 0;
        if (arrayOrg.length < maxOrg)
            return 0;
        //
        idxOrg = 0;
        for (i=0; i<maxDst; i++){
            arrayDst[i] = 0;
            //
            v = 0x000000FF & arrayOrg[idxOrg];
            arrayDst[i] = arrayDst[i] | v;
            idxOrg++;
            //
            v = 0x000000FF & arrayOrg[idxOrg];
            arrayDst[i] = arrayDst[i] | (v << 8);
            idxOrg++;
            //
            v = 0x000000FF & arrayOrg[idxOrg];
            arrayDst[i] = arrayDst[i] | (v << 16);
            idxOrg++;
            //
            v = 0x000000FF & arrayOrg[idxOrg];
            arrayDst[i] = arrayDst[i] | (v << 24);
            idxOrg++;
        }
        //
        return maxDst;
    }