web-dev-qa-db-fra.com

Comment convertir un tableau d'octets en un tableau Int

Je lis un fichier en utilisant:

int len = (int)(new File(args[0]).length());
    FileInputStream fis =
        new FileInputStream(args[0]);
    byte buf[] = new byte[len];
    fis.read(buf);

Comme je l'ai trouvé ici . Est-il possible de convertir byte array buf à un Int Array? Convertit le Byte Array à Int Array prendra beaucoup plus de place?

Modifier: mon fichier contient des millions d'entiers comme,

100000000 200000000 ..... (écrit en utilisant un fil int normal). Je l'ai lu dans le tampon d'octets. Maintenant, je veux l'envelopper dans le tableau IntBuffer. Comment faire ça ? Je ne veux pas convertir chaque octet en int.

javaarraysintbyteendianness
16
alessandro

Vous avez dit dans les commentaires que vous vouliez que quatre octets du tableau d'entrée correspondent à un entier sur le tableau de sortie, donc cela fonctionne bien.

Dépend de si vous vous attendez à ce que les octets soient dans l'ordre big-endian ou little-endian, mais ...

 IntBuffer intBuf =
   ByteBuffer.wrap(byteArray)
     .order(ByteOrder.BIG_ENDIAN)
     .asIntBuffer();
 int[] array = new int[intBuf.remaining()];
 intBuf.get(array);

Fait, en trois lignes.

33
Louis Wasserman

Conversion tous les 4 octets d'un tableau d'octets en un tableau d'entiers:

public int[] convert(byte buf[]) {
   int intArr[] = new int[buf.length / 4];
   int offset = 0;
   for(int i = 0; i < intArr.length; i++) {
      intArr[i] = (buf[3 + offset] & 0xFF) | ((buf[2 + offset] & 0xFF) << 8) |
                  ((buf[1 + offset] & 0xFF) << 16) | ((buf[0 + offset] & 0xFF) << 24);  
   offset += 4;
   }
   return intArr;
}
5
Chris Dargis

Solution pour convertir un tableau d'octets en un tableau d'entiers, où chaque ensemble de 4 octets représente un entier. L'entrée d'octet est byte[] srcByte. La sortie int est dstInt[].

Octets source en petit bout:

    int shiftBits;
    int byteNum = 0;
    int[] dstInt = new int[srcByte.length/4]; //you might have to hard code the array length

    //Convert array of source bytes (srcByte) into array of integers (dstInt)
    for (int intNum = 0; intNum < srcByte.length/4; ++intNum) {  //for the four integers
        dstInt[intNum] = 0;                                      //Start with the integer = 0

        for(shiftBits = 0; shiftBits < 32; shiftBits += 8) {     //Add in each data byte, lowest first
            dstInt[intNum] |= (srcByte[byteNum++] & 0xFF) << shiftBits;
        }
    }

Pour Big-Endian, remplacez cette ligne:

    for(shiftBits = 24; shiftBits >= 0; shiftBits -= 8)  //Add in each data byte, highest first
1
DotCFile

C'est bon pour toi?

    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

En Java:

  • octet = 8 bits
  • entier = 32 bits

et pour la conversion, vous pouvez faire quelque chose comme:

byte[] byteArray = new byte[] {123, 12, 87};
int[] intArray = new int[byteArray.length];

// converting byteArray to intArray
for (int i = 0; i < byteArray.length; intArray[i] = byteArray[i++]);

System.out.println(Arrays.toString(intArray));

cela produirait:

[123, 12, 87]
0
Francisco Spaeth

Créez un nouveau tableau int et copiez les valeurs, en convertissant au besoin.

int[] arr = new int[len];

for(int i = 0; i < len; i++)
    arr[i] = (int)buf[i];
0
tskuzzy

définir "de manière significative". en Java, un int est de 4 octets, donc par définition, le tableau serait 4x l'espace. Voir: http://docs.Oracle.com/javase/tutorial/Java/nutsandbolts/datatypes.html

Et pendant la conversion, vous devez avoir les deux, donc pendant la partie de copie, vous en utiliseriez encore plus, si vous copiez le tableau entier en même temps.

quant à la conversion, il y a beaucoup de questions liées:

Java - conversion d'un tableau d'octets audio en tableau d'entiers

0
John Gardner