Queue of byte buffers in Java

Question

I want to add ByteBuffers to a queue in java so I have the following code,

public class foo{

private Queue <ByteBuffer> messageQueue = new LinkedList<ByteBuffer>();

    protected boolean queueInit(ByteBuffer bbuf)
    {
        if(bbuf.capacity() > 10000)
        {
            int limit = bbuf.limit();
            bbuf.position(0);
            for(int i = 0;i<limit;i=i+10000)
            {
                int kb = 1024;
                for(int j = 0;j<kb;j++)
                {
                    ByteBuffer temp = ByteBuffer.allocate(kb);
                    temp.array()[j] = bbuf.get(j);
                    System.out.println(temp.get(j));
                    addQueue(temp);
                }
            }
        }
        System.out.println(messageQueue.peek().get(1));
        return true;
    }

private void addQueue(ByteBuffer bbuf)
{
    messageQueue.add(bbuf);
}
}

The inner workings of the for loop appear to work correctly as the temp value is set to the correct value and then that should be added to the queue by calling the addQueue method. However only the first letter of the bytebuffer only gets added to the queue and nothing else. Since when I peek at the first value in the head of the queue I get the number 116 as I should, but when I try to get other values in the head they are 0 which is not correct. Why might this be happening where no other values except for the first value of the bytbuffer are getting added to the head of the queue?

Answer 1

ByteBuffer.allocate creates a new ByteBuffer. In each iteration of your inner j loop, you are creating a new buffer, placing a single byte in it, and passing that buffer to addQueue. You are doing this 1024 times (in each iteration of the outer loop), so you are creating 1024 buffers which have a single byte set; in each buffer, all other bytes will be zero.

You are not using the i loop variable of your outer loop at all. I'm not sure why you'd want to skip over 10000 bytes anyway, if your buffers are only 1024 bytes in size.

The slice method can be used to create smaller ByteBuffers from a larger one:

int kb = 1024;
while (bbuf.remaining() >= kb) {

    ByteBuffer temp = bbuf.slice();
    temp.limit(1024);
    addQueue(temp);

    bbuf.position(bbuf.position() + kb);
}

if (bbuf.hasRemaining()) {
    ByteBuffer temp = bbuf.slice();
    addQueue(temp);
}

It's important to remember that the new ByteBuffers will be sharing content with bbuf. Meaning, making changes to any byte in bbuf would also change exactly one of the sliced buffers. That is probably what you want, as it's more efficient than making copies of the buffer. (Potentially much more efficient, if your original buffer is large; would you really want two copies of a one-gigabyte buffer in memory?)

If you truly need to copy all the bytes into independent buffers, regardless of incurred memory usage, you could have your addQueue method copy each buffer space:

private void addQueue(ByteBuffer bbuf)
{
    bbuf = ByteBuffer.allocate(bbuf.remaining()).put(bbuf); // copy
    bbuf.flip();
    messageQueue.add(bbuf);
}