web-dev-qa-db-fra.com

Comment convertir int [] en octet []

J'ai un tableau d'entiers qui représentent une image RVB et je voudrais le convertir en tableau d'octets et le sauvegarder dans un fichier.

Quel est le meilleur moyen de convertir un tableau d'entiers en tableau d'octets en Java?

javaarraystype-conversion
55
Niko Gamulin

Comme le dit Brian , vous devez déterminer le type de conversion dont vous avez besoin.

Voulez-vous l'enregistrer en tant que fichier image "normal" (jpg, png, etc.)?

Si tel est le cas, vous devriez probablement utiliser l'API Java Image I/O .

Si vous souhaitez l'enregistrer au format "brut", vous devez spécifier l'ordre dans lequel vous écrivez les octets, puis utilisez IntBuffer et NIO.

Voici un exemple d'utilisation d'une combinaison ByteBuffer/IntBuffer:

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]);
        }
    }
}
66
Jon Skeet

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();
}
11
Prabhu R

Vous devez d’abord décider comment convertir un entier en un ensemble d’octets.

Très probablement (?) 1 entier à 4 octets, et utilisez les opérateurs shift (>> ou <<) pour extraire chaque octet (observez l'ordre des octets!). Copier dans un tableau d'octets 4 fois la longueur du tableau entier.

3
Brian Agnew

si votre intention est de sauvegarder dans un fichier, vous voudrez peut-être sauvegarder directement dans un fichier en utilisant FileOutputStream.write:

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

puisqu'il: 

Écrit l'octet spécifié dans ce flux de sortie. Le contrat général pour l'écriture est qu'un octet est écrit dans le flux de sortie. L'octet à écrire est constitué des huit bits de poids faible de l'argument b. Les 24 bits de poids fort de b sont ignorés.

2
dfa

J'ai créé ce code et ça marche 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;
    }
1
ncn32

J'utiliserais 'DataOutputStream' avec 'ByteArrayOutputStream'.

public final class Converter {

    private static final int BYTES_IN_INT = 4;

    private Converter() {}

    public static byte [] convert(int [] array) {
        if (isEmpty(array)) {
            return new byte[0];
        }

        return writeInts(array);
    }

    public static int [] convert(byte [] array) {
        if (isEmpty(array)) {
            return new int[0];
        }

        return readInts(array);
    }

    private static byte [] writeInts(int [] array) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream(array.length * 4);
            DataOutputStream dos = new DataOutputStream(bos);
            for (int i = 0; i < array.length; i++) {
                dos.writeInt(array[i]);
            }

            return bos.toByteArray();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static int [] readInts(byte [] array) {
        try {
            ByteArrayInputStream bis = new ByteArrayInputStream(array);
            DataInputStream dataInputStream = new DataInputStream(bis);
            int size = array.length / BYTES_IN_INT;
            int[] res = new int[size];
            for (int i = 0; i < size; i++) {
                res[i] = dataInputStream.readInt();
            }
            return res;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

    public class ConverterTest {

    @Test
    public void convert() {
        final int [] array = {-1000000, 24000, -1, 40};
        byte [] bytes = Converter.convert(array);
        int [] array2 = Converter.convert(bytes);

        assertTrue(ArrayUtils.equals(array, array2));

        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(bytes));
        System.out.println(Arrays.toString(array2));
    }
}

Impressions:

[-1000000, 24000, -1, 40]
[-1, -16, -67, -64, 0, 0, 93, -64, -1, -1, -1, -1, 0, 0, 0, 40]
[-1000000, 24000, -1, 40]
0
user8290063