Java NIO ByteBuffer

0

In this article we will look into Java NIO ByteBuffer’s operations.

Allocate

We call allocate() on ByteBuffer to create a buffer of bytes. Internally, a byte array is created with the position set to 0.

Put

When we put a new element into the buffer, the element is added to the buffer array element at index defined by position. The position is incremented with each put().

Get

In order to read the elements in buffer call ByteBuffer.get(), it will return the element at index define by position. After each get(), the position gets incremented.

Compact

The bytes between the buffer’s current position and its limit, if any, are copied to the beginning of the buffer.
If we want to read the remaining bytes, we will have to call flip() and then read the individual bytes.

Flip

As we call flip(), limit will be set to the current position and the position will be moved to the first index (zero).

Java NIO ByteBuffer Example

JavaNIOBufferExample:

package com.javarticles.nio;

import java.nio.ByteBuffer;

public class JavaNIOByteBufferExample {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(7);
        System.out.println("Buffer limit: " + buffer.limit() + ", capacity: " + buffer.capacity());
        
        put(buffer, (byte) 1);
        put(buffer, (byte) 3);
        put(buffer, (byte) 5);
        put(buffer, (byte) 7);
        put(buffer, (byte) 9);
        put(buffer, (byte) 11);        
        put(buffer, (byte) 13);        
        
        System.out.println("Flip the buffer");
        buffer.flip();
        for (int i = 0; i < buffer.limit() -2; i++) {
            get(buffer);
        }
        System.out.println("Position " + buffer.position() + ", remaining " + buffer.remaining() + ". Compact the buffer");
        buffer.compact();        
        System.out.println("After compact, position " + buffer.position() + ", remaining " + buffer.remaining() + ", limit " + buffer.limit());

        System.out.println("Read elements. Start");
        for (int i = 0; i < buffer.limit(); i++) {
            System.out.println("Get[" + i + "]=>" + buffer.get(i));
        }
        System.out.println("End");
        flip(buffer);
        for (int i = 0; i <= buffer.remaining(); i++) {
            get(buffer);
        }
    }
    
    private static void put(ByteBuffer buffer, byte b) {
        System.out.println("Put[" + buffer.position() +"]=" + b);
        buffer.put(b);        
        System.out.println("Position " + buffer.position() + ", remaining " + buffer.remaining());
    }
    
    private static void get(ByteBuffer buffer) {
        System.out.println("Get[" + buffer.position() + "]=>" + buffer.get() + ". Remaining " + buffer.remaining());       
    }
    
    private static void flip(ByteBuffer buffer) {
        buffer.flip();
        System.out.println("Flip. Position " + buffer.position() + ", remaining " + buffer.remaining() + ", limit " + buffer.limit());
    }
}

Output:

Buffer limit: 7, capacity: 7
Put[0]=1
Position 1, remaining 6
Put[1]=3
Position 2, remaining 5
Put[2]=5
Position 3, remaining 4
Put[3]=7
Position 4, remaining 3
Put[4]=9
Position 5, remaining 2
Put[5]=11
Position 6, remaining 1
Put[6]=13
Position 7, remaining 0
Flip the buffer
Get[0]=>1. Remaining 6
Get[1]=>3. Remaining 5
Get[2]=>5. Remaining 4
Get[3]=>7. Remaining 3
Get[4]=>9. Remaining 2
Position 5, remaining 2. Compact the buffer
After compact, position 2, remaining 5, limit 7
Read elements. Start
Get[0]=>11
Get[1]=>13
Get[2]=>5
Get[3]=>7
Get[4]=>9
Get[5]=>11
Get[6]=>13
End
Flip. Position 0, remaining 2, limit 2
Get[0]=>11. Remaining 1
Get[1]=>13. Remaining 0

Download the source code

This was an example about java NIO ByteBuffer.

You can download the source code here: javaNIOByteBuffer.zip
Share.

Comments are closed.