Java: Comment convertir un int[] pour byte[]

Question

J'ai un tableau d'entiers qui représentent une image RVB et que vous souhaitez convertir au tableau d'octets et de l'enregistrer dans le fichier.

Quelqu'un sait-il quel est le meilleur moyen de convertir un tableau d'entiers dans le tableau d'octets en Java?

Merci!

Answer 1

Comme Brian dit, vous devez faire ce genre de conversion dont vous avez besoin.

Voulez-vous enregistrer en tant que "normal" fichier image (jpg, png, etc)? Si oui, vous devriez probablement utiliser le Java Image d'e/S de l'API.

Si vous voulez l'enregistrer dans un format "raw", vous aurez besoin de travailler sur l'ordre dans lequel écrire les octets, et ensuite utiliser un IntBuffer et NIO.

Comme un exemple de l'utilisation d'un ByteBuffer/IntBuffer combinaison:

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

Peut-être utiliser cette méthode

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

Vous devez décider comment vous convertir 1 entier à un ensemble d'octets en premier.

Plus probablement (?) 1 d'entier de 4 octets, et la touche shift (>> ou <<) des opérateurs pour obtenir à chaque octet de sortie (montre que l'ordre des octets!). Copie d'un tableau d'octets à 4 fois la longueur du tableau d'entiers.

Answer 4

si votre intention est d'enregistrer le fichier peut-être vous voulez enregistrer directement dans un fichier à l'aide de FileOutputStream.écrire:

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

depuis elle:

Écrit les octets indiqué à ce flux de sortie. Les conditions générales du contrat pour écrire un octet est écrit dans le flux de sortie. L'octet à écrire sont les huit bits de l'argument b. Les 24 bits de poids fort de b sont ignorés.

Answer 5

J'ai créé ce code et ça fonctionne plutôt bien:

    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;
    }