java.lang.Object
- org.apache.mina.common.ByteBuffer

All Implemented Interfaces:

java.lang.Comparable<ByteBuffer>

Direct Known Subclasses:

BaseByteBuffer, ByteBufferProxy
```
public abstract class ByteBuffer
extends java.lang.Object
implements java.lang.Comparable<ByteBuffer>
```
A byte buffer used by MINA applications.
This is a replacement for ByteBuffer. Please refer to ByteBuffer and Buffer documentation for usage. MINA does not use NIO ByteBuffer directly for two reasons:
- It doesn't provide useful getters and putters such as fill, get/putString, and get/putAsciiInt() enough.
- It is hard to distinguish if the buffer is created from MINA buffer pool or not. MINA have to return used buffers back to pool.
- It is difficult to write variable-length data due to its fixed capacity
Allocation

You can get a heap buffer from buffer pool:
```
 ByteBuffer buf = ByteBuffer.allocate(1024, false);
 
```
you can also get a direct buffer from buffer pool:
```
 ByteBuffer buf = ByteBuffer.allocate(1024, true);
 
```
or you can let MINA choose:
```
 ByteBuffer buf = ByteBuffer.allocate(1024);
 
```
Acquire/Release

Please note that you never need to release the allocated buffer because MINA will release it automatically when:
- You pass the buffer by calling IoSession.write(Object).
- You pass the buffer by calling IoFilter.NextFilter.filterWrite(IoSession,IoFilter.WriteRequest).
- You pass the buffer by calling ProtocolEncoderOutput.write(ByteBuffer).
And, you don't need to release any ByteBuffer which is passed as a parameter of IoHandler.messageReceived(IoSession, Object) method. They are released automatically when the method returns.
You have to release buffers manually by calling release() when:
- You allocated a buffer, but didn't pass the buffer to any of two methods above.
- You called acquire() to prevent the buffer from being released.
Wrapping existing NIO buffers and arrays

This class provides a few wrap(...) methods that wraps any NIO buffers and byte arrays. Wrapped MINA buffers are not returned to the buffer pool by default to prevent unexpected memory leakage by default. In case you want to make it pooled, you can call setPooled(boolean) with true flag to enable pooling.
AutoExpand

Writing variable-length data using NIO ByteBuffers is not really easy, and it is because its size is fixed. MINA ByteBuffer introduces autoExpand property. If autoExpand property is true, you never get BufferOverflowException or IndexOutOfBoundsException (except when index is negative). It automatically expands its capacity and limit value. For example:
```
 String greeting = messageBundle.getMessage( "hello" );
 ByteBuffer buf = ByteBuffer.allocate( 16 );
 // Turn on autoExpand (it is off by default)
 buf.setAutoExpand( true );
 buf.putString( greeting, utf8encoder );
 
```
NIO ByteBuffer is reallocated by MINA ByteBuffer behind the scene if the encoded data is larger than 16 bytes. Its capacity and its limit will increase to the last position the string is written.

Derived Buffers

Derived buffers are the buffers which were created by duplicate(), slice(), or asReadOnlyBuffer(). They are useful especially when you broadcast the same messages to multiple IoSessions. Please note that the derived buffers are neither pooled nor auto-expandable. Trying to expand a derived buffer will raise IllegalStateException.

Changing Buffer Allocation and Management Policy

MINA provides a ByteBufferAllocator interface to let you override the default buffer management behavior. There are two allocators provided out-of-the-box:
- PooledByteBufferAllocator (Default)
- SimpleByteBufferAllocator
You can change the allocator by calling setAllocator(ByteBufferAllocator).
See Also:

ByteBufferAllocator

Constructor Summary

Constructors
Modifier Constructor Description

protected ByteBuffer()

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`abstract void`	`acquire()`	Increases the internal reference count of this buffer to defer automatic release.
`static ByteBuffer`	`allocate(int capacity)`	Returns the direct or heap buffer which is capable of the specified size.
`static ByteBuffer`	`allocate(int capacity, boolean direct)`	Returns the buffer which is capable of the specified size.
`abstract byte[]`	`array()`
`abstract int`	`arrayOffset()`
`abstract java.nio.CharBuffer`	`asCharBuffer()`
`abstract java.nio.DoubleBuffer`	`asDoubleBuffer()`
`abstract java.nio.FloatBuffer`	`asFloatBuffer()`
`java.io.InputStream`	`asInputStream()`	Returns an `InputStream` that reads the data from this buffer.
`abstract java.nio.IntBuffer`	`asIntBuffer()`
`abstract java.nio.LongBuffer`	`asLongBuffer()`
`java.io.OutputStream`	`asOutputStream()`	Returns an `OutputStream` that appends the data into this buffer.
`abstract ByteBuffer`	`asReadOnlyBuffer()`
`abstract java.nio.ShortBuffer`	`asShortBuffer()`
`protected ByteBuffer`	`autoExpand(int expectedRemaining)`	This method forwards the call to `expand(int)` only when `autoExpand` property is `true`.
`protected ByteBuffer`	`autoExpand(int pos, int expectedRemaining)`	This method forwards the call to `expand(int)` only when `autoExpand` property is `true`.
`abstract java.nio.ByteBuffer`	`buf()`	Returns the underlying NIO buffer instance.
`abstract int`	`capacity()`
`abstract ByteBuffer`	`capacity(int newCapacity)`	Changes the capacity of this buffer.
`abstract ByteBuffer`	`clear()`
`abstract ByteBuffer`	`compact()`
`int`	`compareTo(ByteBuffer that)`
`abstract ByteBuffer`	`duplicate()`
`boolean`	`equals(java.lang.Object o)`
`ByteBuffer`	`expand(int expectedRemaining)`	Changes the capacity and limit of this buffer so this buffer get the specified `expectedRemaining` room from the current position.
`abstract ByteBuffer`	`expand(int pos, int expectedRemaining)`	Changes the capacity and limit of this buffer so this buffer get the specified `expectedRemaining` room from the specified `pos`.
`ByteBuffer`	`fill(byte value, int size)`	Fills this buffer with the specified value.
`ByteBuffer`	`fill(int size)`	Fills this buffer with `NUL (0x00)`.
`ByteBuffer`	`fillAndReset(byte value, int size)`	Fills this buffer with the specified value.
`ByteBuffer`	`fillAndReset(int size)`	Fills this buffer with `NUL (0x00)`.
`abstract ByteBuffer`	`flip()`
`abstract byte`	`get()`
`ByteBuffer`	`get(byte[] dst)`
`abstract ByteBuffer`	`get(byte[] dst, int offset, int length)`
`abstract byte`	`get(int index)`
`static ByteBufferAllocator`	`getAllocator()`	Returns the current allocator which manages the allocated buffers.
`abstract char`	`getChar()`
`abstract char`	`getChar(int index)`
`abstract double`	`getDouble()`
`abstract double`	`getDouble(int index)`
`abstract float`	`getFloat()`
`abstract float`	`getFloat(int index)`
`java.lang.String`	`getHexDump()`	Returns hexdump of this buffer.
`abstract int`	`getInt()`
`abstract int`	`getInt(int index)`
`abstract long`	`getLong()`
`abstract long`	`getLong(int index)`
`java.lang.Object`	`getObject()`	Reads a Java object from the buffer using the context `ClassLoader` of the current thread.
`java.lang.Object`	`getObject(java.lang.ClassLoader classLoader)`	Reads a Java object from the buffer using the specified `classLoader`.
`java.lang.String`	`getPrefixedString(int prefixLength, java.nio.charset.CharsetDecoder decoder)`	Reads a string which has a length field before the actual encoded string, using the specified `decoder` and returns it.
`java.lang.String`	`getPrefixedString(java.nio.charset.CharsetDecoder decoder)`	Reads a string which has a 16-bit length field before the actual encoded string, using the specified `decoder` and returns it.
`abstract short`	`getShort()`
`abstract short`	`getShort(int index)`
`java.lang.String`	`getString(int fieldSize, java.nio.charset.CharsetDecoder decoder)`	Reads a `NUL`-terminated string from this buffer using the specified `decoder` and returns it.
`java.lang.String`	`getString(java.nio.charset.CharsetDecoder decoder)`	Reads a `NUL`-terminated string from this buffer using the specified `decoder` and returns it.
`short`	`getUnsigned()`	Reads one unsigned byte as a short integer.
`short`	`getUnsigned(int index)`	Reads one byte as an unsigned short integer.
`long`	`getUnsignedInt()`	Reads four bytes unsigned integer.
`long`	`getUnsignedInt(int index)`	Reads four bytes unsigned integer.
`int`	`getUnsignedShort()`	Reads two bytes unsigned integer.
`int`	`getUnsignedShort(int index)`	Reads two bytes unsigned integer.
`int`	`hashCode()`
`boolean`	`hasRemaining()`
`abstract boolean`	`isAutoExpand()`	Returns `true` if and only if `autoExpand` is turned on.
`abstract boolean`	`isDirect()`
`abstract boolean`	`isPooled()`	Returns `true` if and only if this buffer is returned back to the buffer pool when released.
`abstract boolean`	`isReadOnly()`
`static boolean`	`isUseDirectBuffers()`
`abstract int`	`limit()`
`abstract ByteBuffer`	`limit(int newLimit)`
`abstract ByteBuffer`	`mark()`
`abstract int`	`markValue()`	Returns the position of the current mark.
`abstract java.nio.ByteOrder`	`order()`
`abstract ByteBuffer`	`order(java.nio.ByteOrder bo)`
`abstract int`	`position()`
`abstract ByteBuffer`	`position(int newPosition)`
`boolean`	`prefixedDataAvailable(int prefixLength)`	Returns `true` if this buffer contains a data which has a data length as a prefix and the buffer has remaining data as enough as specified in the data length field.
`boolean`	`prefixedDataAvailable(int prefixLength, int maxDataLength)`	Returns `true` if this buffer contains a data which has a data length as a prefix and the buffer has remaining data as enough as specified in the data length field.
`abstract ByteBuffer`	`put(byte b)`
`ByteBuffer`	`put(byte[] src)`
`abstract ByteBuffer`	`put(byte[] src, int offset, int length)`
`abstract ByteBuffer`	`put(int index, byte b)`
`abstract ByteBuffer`	`put(java.nio.ByteBuffer src)`	Writes the content of the specified `src` into this buffer.
`ByteBuffer`	`put(ByteBuffer src)`	Writes the content of the specified `src` into this buffer.
`abstract ByteBuffer`	`putChar(char value)`
`abstract ByteBuffer`	`putChar(int index, char value)`
`abstract ByteBuffer`	`putDouble(double value)`
`abstract ByteBuffer`	`putDouble(int index, double value)`
`abstract ByteBuffer`	`putFloat(float value)`
`abstract ByteBuffer`	`putFloat(int index, float value)`
`abstract ByteBuffer`	`putInt(int value)`
`abstract ByteBuffer`	`putInt(int index, int value)`
`abstract ByteBuffer`	`putLong(int index, long value)`
`abstract ByteBuffer`	`putLong(long value)`
`ByteBuffer`	`putObject(java.lang.Object o)`	Writes the specified Java object to the buffer.
`ByteBuffer`	`putPrefixedString(java.lang.CharSequence val, int prefixLength, int padding, byte padValue, java.nio.charset.CharsetEncoder encoder)`	Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`.
`ByteBuffer`	`putPrefixedString(java.lang.CharSequence in, int prefixLength, int padding, java.nio.charset.CharsetEncoder encoder)`	Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`.
`ByteBuffer`	`putPrefixedString(java.lang.CharSequence in, int prefixLength, java.nio.charset.CharsetEncoder encoder)`	Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`.
`ByteBuffer`	`putPrefixedString(java.lang.CharSequence in, java.nio.charset.CharsetEncoder encoder)`	Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`.
`abstract ByteBuffer`	`putShort(int index, short value)`
`abstract ByteBuffer`	`putShort(short value)`
`ByteBuffer`	`putString(java.lang.CharSequence val, int fieldSize, java.nio.charset.CharsetEncoder encoder)`	Writes the content of `in` into this buffer as a `NUL`-terminated string using the specified `encoder`.
`ByteBuffer`	`putString(java.lang.CharSequence val, java.nio.charset.CharsetEncoder encoder)`	Writes the content of `in` into this buffer using the specified `encoder`.
`abstract void`	`release()`	Releases the specified buffer to buffer pool.
`int`	`remaining()`
`abstract ByteBuffer`	`reset()`
`abstract ByteBuffer`	`rewind()`
`static void`	`setAllocator(ByteBufferAllocator newAllocator)`	Changes the current allocator with the specified one to manage the allocated buffers from now.
`abstract ByteBuffer`	`setAutoExpand(boolean autoExpand)`	Turns on or off `autoExpand`.
`abstract void`	`setPooled(boolean pooled)`	Sets whether this buffer is returned back to the buffer pool when released.
`static void`	`setUseDirectBuffers(boolean useDirectBuffers)`
`ByteBuffer`	`skip(int size)`	Forwards the position of this buffer as the specified `size` bytes.
`abstract ByteBuffer`	`slice()`
`ByteBuffer`	`sweep()`	Clears this buffer and fills its content with `NUL`.
`ByteBuffer`	`sweep(byte value)`	Clears this buffer and fills its content with `value`.
`java.lang.String`	`toString()`
`static ByteBuffer`	`wrap(byte[] byteArray)`	Wraps the specified byte array into MINA heap buffer.
`static ByteBuffer`	`wrap(byte[] byteArray, int offset, int length)`	Wraps the specified byte array into MINA heap buffer.
`static ByteBuffer`	`wrap(java.nio.ByteBuffer nioBuffer)`	Wraps the specified NIO `ByteBuffer` into MINA buffer.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - ByteBuffer
```
protected ByteBuffer()
```
- Method Detail
  - getAllocator
```
public static ByteBufferAllocator getAllocator()
```
    Returns the current allocator which manages the allocated buffers.
  - setAllocator
```
public static void setAllocator(ByteBufferAllocator newAllocator)
```
    Changes the current allocator with the specified one to manage the allocated buffers from now.
  - isUseDirectBuffers
```
public static boolean isUseDirectBuffers()
```
  - setUseDirectBuffers
```
public static void setUseDirectBuffers(boolean useDirectBuffers)
```
  - allocate
```
public static ByteBuffer allocate(int capacity)
```
    Returns the direct or heap buffer which is capable of the specified size. This method tries to allocate direct buffer first, and then tries heap buffer if direct buffer memory is exhausted. Please use allocate(int, boolean) to allocate buffers of specific type.
    
    Parameters:
    
    capacity - the capacity of the buffer
  - allocate
```
public static ByteBuffer allocate(int capacity,
                                  boolean direct)
```
    Returns the buffer which is capable of the specified size.
    
    Parameters:
    
    capacity - the capacity of the buffer
    
    direct - true to get a direct buffer, false to get a heap buffer.
  - wrap
```
public static ByteBuffer wrap(java.nio.ByteBuffer nioBuffer)
```
    Wraps the specified NIO ByteBuffer into MINA buffer.
  - wrap
```
public static ByteBuffer wrap(byte[] byteArray)
```
    Wraps the specified byte array into MINA heap buffer.
  - wrap
```
public static ByteBuffer wrap(byte[] byteArray,
                              int offset,
                              int length)
```
    Wraps the specified byte array into MINA heap buffer. Please note that MINA buffers are going to be pooled, and therefore there can be waste of memory if you wrap your byte array specifying offset and length.
  - acquire
```
public abstract void acquire()
```
    Increases the internal reference count of this buffer to defer automatic release. You have to invoke release() as many as you invoked this method to release this buffer.
    
    Throws:
    
    java.lang.IllegalStateException - if you attempt to acquire already released buffer.
  - release
```
public abstract void release()
```
    Releases the specified buffer to buffer pool.
    
    Throws:
    
    java.lang.IllegalStateException - if you attempt to release already released buffer.
  - buf
```
public abstract java.nio.ByteBuffer buf()
```
    Returns the underlying NIO buffer instance.
  - isDirect
```
public abstract boolean isDirect()
```
    See Also:
    
    ByteBuffer.isDirect()
  - isReadOnly
```
public abstract boolean isReadOnly()
```
    See Also:
    
    Buffer.isReadOnly()
  - capacity
```
public abstract int capacity()
```
    See Also:
    
    Buffer.capacity()
  - capacity
```
public abstract ByteBuffer capacity(int newCapacity)
```
    Changes the capacity of this buffer.
  - isAutoExpand
```
public abstract boolean isAutoExpand()
```
    Returns true if and only if autoExpand is turned on.
  - setAutoExpand
```
public abstract ByteBuffer setAutoExpand(boolean autoExpand)
```
    Turns on or off autoExpand.
  - expand
```
public ByteBuffer expand(int expectedRemaining)
```
    Changes the capacity and limit of this buffer so this buffer get the specified expectedRemaining room from the current position. This method works even if you didn't set autoExpand to true.
  - expand
```
public abstract ByteBuffer expand(int pos,
                                  int expectedRemaining)
```
    Changes the capacity and limit of this buffer so this buffer get the specified expectedRemaining room from the specified pos. This method works even if you didn't set autoExpand to true.
  - isPooled
```
public abstract boolean isPooled()
```
    Returns true if and only if this buffer is returned back to the buffer pool when released.
    The default value of this property is true if and only if you allocated this buffer using allocate(int) or allocate(int, boolean), or false otherwise. (i.e. wrap(byte[]), wrap(byte[], int, int), and wrap(java.nio.ByteBuffer))
  - setPooled
```
public abstract void setPooled(boolean pooled)
```
    Sets whether this buffer is returned back to the buffer pool when released.
    The default value of this property is true if and only if you allocated this buffer using allocate(int) or allocate(int, boolean), or false otherwise. (i.e. wrap(byte[]), wrap(byte[], int, int), and wrap(java.nio.ByteBuffer))
  - position
```
public abstract int position()
```
    See Also:
    
    Buffer.position()
  - position
```
public abstract ByteBuffer position(int newPosition)
```
    See Also:
    
    Buffer.position(int)
  - limit
```
public abstract int limit()
```
    See Also:
    
    Buffer.limit()
  - limit
```
public abstract ByteBuffer limit(int newLimit)
```
    See Also:
    
    Buffer.limit(int)
  - mark
```
public abstract ByteBuffer mark()
```
    See Also:
    
    Buffer.mark()
  - markValue
```
public abstract int markValue()
```
    Returns the position of the current mark. This method returns -1 if no mark is set.
  - reset
```
public abstract ByteBuffer reset()
```
    See Also:
    
    Buffer.reset()
  - clear
```
public abstract ByteBuffer clear()
```
    See Also:
    
    Buffer.clear()
  - sweep
```
public ByteBuffer sweep()
```
    Clears this buffer and fills its content with NUL. The position is set to zero, the limit is set to the capacity, and the mark is discarded.
  - sweep
```
public ByteBuffer sweep(byte value)
```
    Clears this buffer and fills its content with value. The position is set to zero, the limit is set to the capacity, and the mark is discarded.
  - flip
```
public abstract ByteBuffer flip()
```
    See Also:
    
    Buffer.flip()
  - rewind
```
public abstract ByteBuffer rewind()
```
    See Also:
    
    Buffer.rewind()
  - remaining
```
public int remaining()
```
    See Also:
    
    Buffer.remaining()
  - hasRemaining
```
public boolean hasRemaining()
```
    See Also:
    
    Buffer.hasRemaining()
  - duplicate
```
public abstract ByteBuffer duplicate()
```
    See Also:
    
    ByteBuffer.duplicate()
  - slice
```
public abstract ByteBuffer slice()
```
    See Also:
    
    ByteBuffer.slice()
  - asReadOnlyBuffer
```
public abstract ByteBuffer asReadOnlyBuffer()
```
    See Also:
    
    ByteBuffer.asReadOnlyBuffer()
  - array
```
public abstract byte[] array()
```
    See Also:
    
    ByteBuffer.array()
  - arrayOffset
```
public abstract int arrayOffset()
```
    See Also:
    
    ByteBuffer.arrayOffset()
  - get
```
public abstract byte get()
```
    See Also:
    
    ByteBuffer.get()
  - getUnsigned
```
public short getUnsigned()
```
    Reads one unsigned byte as a short integer.
  - put
```
public abstract ByteBuffer put(byte b)
```
    See Also:
    
    ByteBuffer.put(byte)
  - get
```
public abstract byte get(int index)
```
    See Also:
    
    ByteBuffer.get(int)
  - getUnsigned
```
public short getUnsigned(int index)
```
    Reads one byte as an unsigned short integer.
  - put
```
public abstract ByteBuffer put(int index,
                               byte b)
```
    See Also:
    
    ByteBuffer.put(int, byte)
  - get
```
public abstract ByteBuffer get(byte[] dst,
                               int offset,
                               int length)
```
    See Also:
    
    ByteBuffer.get(byte[], int, int)
  - get
```
public ByteBuffer get(byte[] dst)
```
    See Also:
    
    ByteBuffer.get(byte[])
  - put
```
public abstract ByteBuffer put(java.nio.ByteBuffer src)
```
    Writes the content of the specified src into this buffer.
  - put
```
public ByteBuffer put(ByteBuffer src)
```
    Writes the content of the specified src into this buffer.
  - put
```
public abstract ByteBuffer put(byte[] src,
                               int offset,
                               int length)
```
    See Also:
    
    ByteBuffer.put(byte[], int, int)
  - put
```
public ByteBuffer put(byte[] src)
```
    See Also:
    
    ByteBuffer.put(byte[])
  - compact
```
public abstract ByteBuffer compact()
```
    See Also:
    
    ByteBuffer.compact()
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - compareTo
```
public int compareTo(ByteBuffer that)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<ByteBuffer>
  - order
```
public abstract java.nio.ByteOrder order()
```
    See Also:
    
    ByteBuffer.order()
  - order
```
public abstract ByteBuffer order(java.nio.ByteOrder bo)
```
    See Also:
    
    ByteBuffer.order(ByteOrder)
  - getChar
```
public abstract char getChar()
```
    See Also:
    
    ByteBuffer.getChar()
  - putChar
```
public abstract ByteBuffer putChar(char value)
```
    See Also:
    
    ByteBuffer.putChar(char)
  - getChar
```
public abstract char getChar(int index)
```
    See Also:
    
    ByteBuffer.getChar(int)
  - putChar
```
public abstract ByteBuffer putChar(int index,
                                   char value)
```
    See Also:
    
    ByteBuffer.putChar(int, char)
  - asCharBuffer
```
public abstract java.nio.CharBuffer asCharBuffer()
```
    See Also:
    
    ByteBuffer.asCharBuffer()
  - getShort
```
public abstract short getShort()
```
    See Also:
    
    ByteBuffer.getShort()
  - getUnsignedShort
```
public int getUnsignedShort()
```
    Reads two bytes unsigned integer.
  - putShort
```
public abstract ByteBuffer putShort(short value)
```
    See Also:
    
    ByteBuffer.putShort(short)
  - getShort
```
public abstract short getShort(int index)
```
    See Also:
    
    ByteBuffer.getShort()
  - getUnsignedShort
```
public int getUnsignedShort(int index)
```
    Reads two bytes unsigned integer.
  - putShort
```
public abstract ByteBuffer putShort(int index,
                                    short value)
```
    See Also:
    
    ByteBuffer.putShort(int, short)
  - asShortBuffer
```
public abstract java.nio.ShortBuffer asShortBuffer()
```
    See Also:
    
    ByteBuffer.asShortBuffer()
  - getInt
```
public abstract int getInt()
```
    See Also:
    
    ByteBuffer.getInt()
  - getUnsignedInt
```
public long getUnsignedInt()
```
    Reads four bytes unsigned integer.
  - putInt
```
public abstract ByteBuffer putInt(int value)
```
    See Also:
    
    ByteBuffer.putInt(int)
  - getInt
```
public abstract int getInt(int index)
```
    See Also:
    
    ByteBuffer.getInt(int)
  - getUnsignedInt
```
public long getUnsignedInt(int index)
```
    Reads four bytes unsigned integer.
  - putInt
```
public abstract ByteBuffer putInt(int index,
                                  int value)
```
    See Also:
    
    ByteBuffer.putInt(int, int)
  - asIntBuffer
```
public abstract java.nio.IntBuffer asIntBuffer()
```
    See Also:
    
    ByteBuffer.asIntBuffer()
  - getLong
```
public abstract long getLong()
```
    See Also:
    
    ByteBuffer.getLong()
  - putLong
```
public abstract ByteBuffer putLong(long value)
```
    See Also:
    
    ByteBuffer.putLong(int, long)
  - getLong
```
public abstract long getLong(int index)
```
    See Also:
    
    ByteBuffer.getLong(int)
  - putLong
```
public abstract ByteBuffer putLong(int index,
                                   long value)
```
    See Also:
    
    ByteBuffer.putLong(int, long)
  - asLongBuffer
```
public abstract java.nio.LongBuffer asLongBuffer()
```
    See Also:
    
    ByteBuffer.asLongBuffer()
  - getFloat
```
public abstract float getFloat()
```
    See Also:
    
    ByteBuffer.getFloat()
  - putFloat
```
public abstract ByteBuffer putFloat(float value)
```
    See Also:
    
    ByteBuffer.putFloat(float)
  - getFloat
```
public abstract float getFloat(int index)
```
    See Also:
    
    ByteBuffer.getFloat(int)
  - putFloat
```
public abstract ByteBuffer putFloat(int index,
                                    float value)
```
    See Also:
    
    ByteBuffer.putFloat(int, float)
  - asFloatBuffer
```
public abstract java.nio.FloatBuffer asFloatBuffer()
```
    See Also:
    
    ByteBuffer.asFloatBuffer()
  - getDouble
```
public abstract double getDouble()
```
    See Also:
    
    ByteBuffer.getDouble()
  - putDouble
```
public abstract ByteBuffer putDouble(double value)
```
    See Also:
    
    ByteBuffer.putDouble(double)
  - getDouble
```
public abstract double getDouble(int index)
```
    See Also:
    
    ByteBuffer.getDouble(int)
  - putDouble
```
public abstract ByteBuffer putDouble(int index,
                                     double value)
```
    See Also:
    
    ByteBuffer.putDouble(int, double)
  - asDoubleBuffer
```
public abstract java.nio.DoubleBuffer asDoubleBuffer()
```
    See Also:
    
    ByteBuffer.asDoubleBuffer()
  - asInputStream
```
public java.io.InputStream asInputStream()
```
    Returns an InputStream that reads the data from this buffer. InputStream.read() returns -1 if the buffer position reaches to the limit.
  - asOutputStream
```
public java.io.OutputStream asOutputStream()
```
    Returns an OutputStream that appends the data into this buffer. Please note that the OutputStream.write(int) will throw a BufferOverflowException instead of an IOException in case of buffer overflow. Please set autoExpand property by calling setAutoExpand(boolean) to prevent the unexpected runtime exception.
  - getHexDump
```
public java.lang.String getHexDump()
```
    Returns hexdump of this buffer.
  - getString
```
public java.lang.String getString(java.nio.charset.CharsetDecoder decoder)
                           throws java.nio.charset.CharacterCodingException
```
    Reads a NUL-terminated string from this buffer using the specified decoder and returns it. This method reads until the limit of this buffer if no NUL is found.
    
    Throws:
    
    java.nio.charset.CharacterCodingException
  - getString
```
public java.lang.String getString(int fieldSize,
                                  java.nio.charset.CharsetDecoder decoder)
                           throws java.nio.charset.CharacterCodingException
```
    Reads a NUL-terminated string from this buffer using the specified decoder and returns it.
    
    Parameters:
    
    fieldSize - the maximum number of bytes to read
    
    Throws:
    
    java.nio.charset.CharacterCodingException
  - putString
```
public ByteBuffer putString(java.lang.CharSequence val,
                            java.nio.charset.CharsetEncoder encoder)
                     throws java.nio.charset.CharacterCodingException
```
    Writes the content of in into this buffer using the specified encoder. This method doesn't terminate string with NUL. You have to do it by yourself.
    
    Throws:
    
    java.nio.BufferOverflowException - if the specified string doesn't fit
    
    java.nio.charset.CharacterCodingException
  - putString
```
public ByteBuffer putString(java.lang.CharSequence val,
                            int fieldSize,
                            java.nio.charset.CharsetEncoder encoder)
                     throws java.nio.charset.CharacterCodingException
```
    Writes the content of in into this buffer as a NUL-terminated string using the specified encoder.
    If the charset name of the encoder is UTF-16, you cannot specify odd fieldSize, and this method will append two NULs as a terminator.
    Please note that this method doesn't terminate with NUL if the input string is longer than fieldSize.
    
    Parameters:
    
    fieldSize - the maximum number of bytes to write
    
    Throws:
    
    java.nio.charset.CharacterCodingException
  - getPrefixedString
```
public java.lang.String getPrefixedString(java.nio.charset.CharsetDecoder decoder)
                                   throws java.nio.charset.CharacterCodingException
```
    Reads a string which has a 16-bit length field before the actual encoded string, using the specified decoder and returns it. This method is a shortcut for getPrefixedString(2, decoder).
    
    Throws:
    
    java.nio.charset.CharacterCodingException
  - getPrefixedString
```
public java.lang.String getPrefixedString(int prefixLength,
                                          java.nio.charset.CharsetDecoder decoder)
                                   throws java.nio.charset.CharacterCodingException
```
    Reads a string which has a length field before the actual encoded string, using the specified decoder and returns it.
    
    Parameters:
    
    prefixLength - the length of the length field (1, 2, or 4)
    
    Throws:
    
    java.nio.charset.CharacterCodingException
  - putPrefixedString
```
public ByteBuffer putPrefixedString(java.lang.CharSequence in,
                                    java.nio.charset.CharsetEncoder encoder)
                             throws java.nio.charset.CharacterCodingException
```
    Writes the content of in into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified encoder. This method is a shortcut for putPrefixedString(in, 2, 0, encoder).
    
    Throws:
    
    java.nio.BufferOverflowException - if the specified string doesn't fit
    
    java.nio.charset.CharacterCodingException
  - putPrefixedString
```
public ByteBuffer putPrefixedString(java.lang.CharSequence in,
                                    int prefixLength,
                                    java.nio.charset.CharsetEncoder encoder)
                             throws java.nio.charset.CharacterCodingException
```
    Writes the content of in into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified encoder. This method is a shortcut for putPrefixedString(in, prefixLength, 0, encoder).
    
    Parameters:
    
    prefixLength - the length of the length field (1, 2, or 4)
    
    Throws:
    
    java.nio.BufferOverflowException - if the specified string doesn't fit
    
    java.nio.charset.CharacterCodingException
  - putPrefixedString
```
public ByteBuffer putPrefixedString(java.lang.CharSequence in,
                                    int prefixLength,
                                    int padding,
                                    java.nio.charset.CharsetEncoder encoder)
                             throws java.nio.charset.CharacterCodingException
```
    Writes the content of in into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified encoder. This method is a shortcut for putPrefixedString(in, prefixLength, padding, ( byte ) 0, encoder).
    
    Parameters:
    
    prefixLength - the length of the length field (1, 2, or 4)
    
    padding - the number of padded NULs (1 (or 0), 2, or 4)
    
    Throws:
    
    java.nio.BufferOverflowException - if the specified string doesn't fit
    
    java.nio.charset.CharacterCodingException
  - putPrefixedString
```
public ByteBuffer putPrefixedString(java.lang.CharSequence val,
                                    int prefixLength,
                                    int padding,
                                    byte padValue,
                                    java.nio.charset.CharsetEncoder encoder)
                             throws java.nio.charset.CharacterCodingException
```
    Writes the content of in into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified encoder.
    
    Parameters:
    
    prefixLength - the length of the length field (1, 2, or 4)
    
    padding - the number of padded bytes (1 (or 0), 2, or 4)
    
    padValue - the value of padded bytes
    
    Throws:
    
    java.nio.BufferOverflowException - if the specified string doesn't fit
    
    java.nio.charset.CharacterCodingException
  - getObject
```
public java.lang.Object getObject()
                           throws java.lang.ClassNotFoundException
```
    Reads a Java object from the buffer using the context ClassLoader of the current thread.
    
    Throws:
    
    java.lang.ClassNotFoundException
  - getObject
```
public java.lang.Object getObject(java.lang.ClassLoader classLoader)
                           throws java.lang.ClassNotFoundException
```
    Reads a Java object from the buffer using the specified classLoader.
    
    Throws:
    
    java.lang.ClassNotFoundException
  - putObject
```
public ByteBuffer putObject(java.lang.Object o)
```
    Writes the specified Java object to the buffer.
  - prefixedDataAvailable
```
public boolean prefixedDataAvailable(int prefixLength)
```
    Returns true if this buffer contains a data which has a data length as a prefix and the buffer has remaining data as enough as specified in the data length field. This method is identical with prefixedDataAvailable( prefixLength, Integer.MAX_VALUE ). Please not that using this method can allow DoS (Denial of Service) attack in case the remote peer sends too big data length value. It is recommended to use prefixedDataAvailable(int, int) instead.
    
    Parameters:
    
    prefixLength - the length of the prefix field (1, 2, or 4)
    
    Throws:
    
    java.lang.IllegalArgumentException - if prefixLength is wrong
    
    BufferDataException - if data length is negative
  - prefixedDataAvailable
```
public boolean prefixedDataAvailable(int prefixLength,
                                     int maxDataLength)
```
    Returns true if this buffer contains a data which has a data length as a prefix and the buffer has remaining data as enough as specified in the data length field.
    
    Parameters:
    
    prefixLength - the length of the prefix field (1, 2, or 4)
    
    maxDataLength - the allowed maximum of the read data length
    
    Throws:
    
    java.lang.IllegalArgumentException - if prefixLength is wrong
    
    BufferDataException - if data length is negative or greater then maxDataLength
  - skip
```
public ByteBuffer skip(int size)
```
    Forwards the position of this buffer as the specified size bytes.
  - fill
```
public ByteBuffer fill(byte value,
                       int size)
```
    Fills this buffer with the specified value. This method moves buffer position forward.
  - fillAndReset
```
public ByteBuffer fillAndReset(byte value,
                               int size)
```
    Fills this buffer with the specified value. This method does not change buffer position.
  - fill
```
public ByteBuffer fill(int size)
```
    Fills this buffer with NUL (0x00). This method moves buffer position forward.
  - fillAndReset
```
public ByteBuffer fillAndReset(int size)
```
    Fills this buffer with NUL (0x00). This method does not change buffer position.
  - autoExpand
```
protected ByteBuffer autoExpand(int expectedRemaining)
```
    This method forwards the call to expand(int) only when autoExpand property is true.
  - autoExpand
```
protected ByteBuffer autoExpand(int pos,
                                int expectedRemaining)
```
    This method forwards the call to expand(int) only when autoExpand property is true.

Class ByteBuffer

Allocation

Acquire/Release

Wrapping existing NIO buffers and arrays

AutoExpand

Derived Buffers

Changing Buffer Allocation and Management Policy

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ByteBuffer

Method Detail

getAllocator

setAllocator

isUseDirectBuffers

setUseDirectBuffers

allocate

allocate

wrap

wrap

wrap

acquire

release

buf

isDirect

isReadOnly

capacity

capacity

isAutoExpand

setAutoExpand

expand

expand

isPooled

setPooled

position

position

limit

limit

mark

markValue

reset

clear

sweep

sweep

flip

rewind

remaining

hasRemaining

duplicate

slice

asReadOnlyBuffer

array

arrayOffset

get

getUnsigned

put

get

getUnsigned

put

get

get

put

put

put

put

compact

toString

hashCode

equals

compareTo

order

order

getChar

putChar

getChar

putChar

asCharBuffer

getShort

getUnsignedShort