CODEWITHSUNDEEP
javaarraysintbyteendianness
alessandro
alessandro

Reputation: 1721

How to convert a Byte Array to an Int Array

I am reading a file by using:

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

As I found here. Is it possible to convert byte array buf to an Int Array ? Is converting the Byte Array to Int Array will take significantly more space ?

Edit: my file contains millions of ints like,

100000000 200000000 ..... (written using normal int file wirte). I read it to byte buffer. Now I want to wrap it into IntBuffer array. How to do that ? I dont want to convert each byte to int.

Upvotes: 22

Views: 72122

Answers (7)

DotCFile
DotCFile

Reputation: 119

Solution for converting an array of bytes into an array of integers, where each set of 4 bytes represents an integer. The byte input is byte[] srcByte. The int output is dstInt[].

Little-endian source bytes:

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

For Big-Endian substitute this line:

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

Upvotes: 0

ncn32
ncn32

Reputation: 21

Is this ok for you?

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

Upvotes: 1

Louis Wasserman
Louis Wasserman

Reputation: 198023

You've said in the comments that you want four bytes from the input array to correspond to one integer on the output array, so that works out nicely.

Depends on whether you expect the bytes to be in big-endian or little-endian order, but...

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

Done, in three lines.

Upvotes: 60

Chris Dargis
Chris Dargis

Reputation: 6043

Converting every 4 bytes of a byte array into an integer array:

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

Upvotes: 6

Francisco Spaeth
Francisco Spaeth

Reputation: 23893

In java:

  • byte = 8 bits
  • integer = 32 bits

and for conversion you could do something like:

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

this would output:

[123, 12, 87]

Upvotes: 2

John Gardner
John Gardner

Reputation: 25116

define "significantly". in java, an int is 4 bytes, so by definition the array would be 4x the space. See: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

And during the conversion, you have to have both, so during the copy portion, you'd be using even more, if you were copying the whole array at once.

as for the conversion, there are many related questions:

Java - converting byte array of audio into integer array

Upvotes: 0

tskuzzy
tskuzzy

Reputation: 36446

Create a new int array and copy over the values, casting as needed.

int[] arr = new int[len];

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

Upvotes: -1

Related Questions