OpenJDK 27 · java.nio.Buffer · APIdia, the JavaDoc alternative

A container for data of a specific primitive type.

A buffer is a linear, finite sequence of elements of a specific primitive type. Aside from its content, the essential properties of a buffer are its capacity, limit, and position:

A buffer's capacity is the number of elements it contains. The capacity of a buffer is never negative and never changes.

A buffer's limit is the index of the first element that should not be read or written. A buffer's limit is never negative and is never greater than its capacity.

A buffer's position is the index of the next element to be read or written. A buffer's position is never negative and is never greater than its limit.

There is one subclass of this class for each non-boolean primitive type.

Transferring data

Each subclass of this class defines two categories of get and put operations:

Relative operations read or write one or more elements starting at the current position and then increment the position by the number of elements transferred. If the requested transfer exceeds the limit then a relative get operation throws a BufferUnderflowException and a relative put operation throws a BufferOverflowException; in either case, no data is transferred.

Absolute operations take an explicit element index and do not affect the position. Absolute get and put operations throw an IndexOutOfBoundsException if the index argument exceeds the limit.

Data may also, of course, be transferred in to or out of a buffer by the I/O operations of an appropriate channel, which are always relative to the current position.

Marking and resetting

A buffer's mark is the index to which its position will be reset when the reset method is invoked. The mark is not always defined, but when it is defined it is never negative and is never greater than the position. If the mark is defined then it is discarded when the position or the limit is adjusted to a value smaller than the mark. If the mark is not defined then invoking the reset method causes an InvalidMarkException to be thrown.

Invariants

The following invariant holds for the mark, position, limit, and capacity values:

0 <= mark <= position <= limit <= capacity

A newly-created buffer always has a position of zero and a mark that is undefined. The initial limit may be zero, or it may be some other value that depends upon the type of the buffer and the manner in which it is constructed. Each element of a newly-allocated buffer is initialized to zero.

Additional operations

In addition to methods for accessing the position, limit, and capacity values and for marking and resetting, this class also defines the following operations upon buffers:

clear makes a buffer ready for a new sequence of channel-read or relative put operations: It sets the limit to the capacity and the position to zero.
flip makes a buffer ready for a new sequence of channel-write or relative get operations: It sets the limit to the current position and then sets the position to zero.
rewind makes a buffer ready for re-reading the data that it already contains: It leaves the limit unchanged and sets the position to zero.
The slice and slice(index,length) methods create a subsequence of a buffer: They leave the limit and the position unchanged.
duplicate creates a shallow copy of a buffer: It leaves the limit and the position unchanged.

Read-only buffers

Every buffer is readable, but not every buffer is writable. The mutation methods of each buffer class are specified as optional operations that will throw a ReadOnlyBufferException when invoked upon a read-only buffer. A read-only buffer does not allow its content to be changed, but its mark, position, and limit values are mutable. Whether or not a buffer is read-only may be determined by invoking its isReadOnly method.

Thread safety

Buffers are not safe for use by multiple concurrent threads. If a buffer is to be used by more than one thread then access to the buffer should be controlled by appropriate synchronization.

Invocation chaining

Methods in this class that do not otherwise have a value to return are specified to return the buffer upon which they are invoked. This allows method invocations to be chained; for example, the sequence of statements

b.flip();
b.position(23);
b.limit(42);

can be replaced by the single, more compact statement

b.flip().position(23).limit(42);

Field Summary

Modifier and Type	Field and Description
pack-priv long	address
private final int	capacity
private static final BiFunction<String, List<Number>, IndexOutOfBoundsException>	IOOBE_FORMATTER Exception formatter that returns an `IndexOutOfBoundsException` with no detail message.
private int	limit
private int	mark
private int	position
pack-priv static final ScopedMemoryAccess	SCOPED_MEMORY_ACCESS
pack-priv final MemorySegment	segment
pack-priv static final int	SPLITERATOR_CHARACTERISTICS The characteristics of Spliterators that traverse and split elements maintained in Buffers.
pack-priv static final Unsafe	UNSAFE

Constructor Summary

Access	Constructor and Description
pack-priv	Buffer(long addr, int cap, MemorySegment segment)
pack-priv	Buffer(int mark, int pos, int lim, int cap, MemorySegment segment)

Method Summary

Modifier and Type	Method and Description
public abstract Object	Returns: The array that backs this buffer array() Returns the array that backs this buffer (optional operation).
public abstract int	Returns: The offset within this buffer's array of the first element of the buffer arrayOffset() Returns the offset within this buffer's backing array of the first element of the buffer (optional operation).
pack-priv abstract Object	base() Returns: the base reference, paired with the address field, which in combination can be used for unsafe access into a heap buffer or direct byte buffer (and views of).
public final int	Returns: The capacity of this buffer capacity() Returns this buffer's capacity.
pack-priv final int	checkIndex(int i) Checks the given index against the limit, throwing an `IndexOutOfBoundsException` if it is greater than the limit or is negative.
pack-priv final int	checkIndex(int i, int nb) Checks the given index and number of bytes against the range `[0, limit]`, throwing an `IndexOutOfBoundsException` if the index is negative or the index plus the number of bytes is greater than the limit.
pack-priv final void	checkSession()
public Buffer	Returns: This buffer clear() Clears this buffer.
pack-priv static IllegalArgumentException	createCapacityException(int The new buffer's capacity, in $type$s capacity) Verify that the capacity is nonnegative.
private IllegalArgumentException	createLimitException(int The new limit value newLimit) Verify that `0 < newLimit <= capacity`
private IllegalArgumentException	createPositionException(int The new position value newPosition) Verify that `0 < newPosition <= limit`
pack-priv static IllegalArgumentException	Returns: IllegalArgumentException With a message indicating equal source and target buffers createSameBufferException() Returns an `IllegalArgumentException` indicating that the source and target are the same `Buffer`.
pack-priv final void	discardMark()
public abstract Buffer	Returns: The new buffer duplicate() Creates a new buffer that shares this buffer's content.
public Buffer	Returns: This buffer flip() Flips this buffer.
public abstract boolean	Returns: `true` if, and only if, this buffer is backed by an array and is not read-only hasArray() Tells whether or not this buffer is backed by an accessible array.
public final boolean	Returns: `true` if, and only if, there is at least one element remaining in this buffer hasRemaining() Tells whether there are any elements between the current position and the limit.
pack-priv abstract AbstractMemorySegmentImpl	heapSegment(Object base, long offset, long length, boolean readOnly, MemorySessionImpl bufferScope)
public abstract boolean	Returns: `true` if, and only if, this buffer is direct isDirect() Tells whether or not this buffer is direct.
public abstract boolean	Returns: `true` if, and only if, this buffer is read-only isReadOnly() Tells whether or not this buffer is read-only.
public final int	Returns: The limit of this buffer limit() Returns this buffer's limit.
public Buffer	Returns: This buffer limit(int The new limit value; must be non-negative and no larger than this buffer's capacity newLimit) Sets this buffer's limit.
public Buffer	Returns: This buffer mark() Sets this buffer's mark at its position.
pack-priv final int	markValue()
pack-priv final int	Returns: The current position value, before it is incremented nextGetIndex() Checks the current position against the limit, throwing a `BufferUnderflowException` if it is not smaller than the limit, and then increments the position.
pack-priv final int	nextGetIndex(int nb)
pack-priv final int	Returns: The current position value, before it is incremented nextPutIndex() Checks the current position against the limit, throwing a `BufferOverflowException` if it is not smaller than the limit, and then increments the position.
pack-priv final int	nextPutIndex(int nb)
public final int	Returns: The position of this buffer position() Returns this buffer's position.
public Buffer	Returns: This buffer position(int The new position value; must be non-negative and no larger than the current limit newPosition) Sets this buffer's position.
public final int	Returns: The number of elements remaining in this buffer remaining() Returns the number of elements between the current position and the limit.
public Buffer	Returns: This buffer reset() Resets this buffer's position to the previously-marked position.
public Buffer	Returns: This buffer rewind() Rewinds this buffer.
pack-priv abstract int	Returns: the scale shifts for this Buffer scaleShifts() Returns the scale shifts for this Buffer.
pack-priv final MemorySessionImpl	session()
public abstract Buffer	Returns: The new buffer slice() Creates a new buffer whose content is a shared subsequence of this buffer's content.
public abstract Buffer	Returns: The new buffer slice(int The position in this buffer at which the content of the new buffer will start; must be non-negative and no larger than `limit()` index, int The number of elements the new buffer will contain; must be non-negative and no larger than `limit() - index` length) Creates a new buffer whose content is a shared subsequence of this buffer's content.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

address	back to summary
pack-priv long address

capacity	back to summary
private final int capacity

IOOBE_FORMATTER	back to summary
private static final BiFunction<String, List<Number>, IndexOutOfBoundsException> IOOBE_FORMATTER Exception formatter that returns an `IndexOutOfBoundsException` with no detail message.

limit	back to summary
private int limit

mark	back to summary
private int mark

position	back to summary
private int position

SCOPED_MEMORY_ACCESS	back to summary
pack-priv static final ScopedMemoryAccess SCOPED_MEMORY_ACCESS

segment	back to summary
pack-priv final MemorySegment segment

SPLITERATOR_CHARACTERISTICS	back to summary
pack-priv static final int SPLITERATOR_CHARACTERISTICS The characteristics of Spliterators that traverse and split elements maintained in Buffers.

UNSAFE	back to summary
pack-priv static final Unsafe UNSAFE

Constructor Detail

Buffer	back to summary
pack-priv Buffer(long addr, int cap, MemorySegment segment)

Buffer	back to summary
pack-priv Buffer(int mark, int pos, int lim, int cap, MemorySegment segment)

Method Detail

array back to summary

array	back to summary
public abstract Object array() Returns the array that backs this buffer (optional operation). This method is intended to allow array-backed buffers to be passed to native code more efficiently. Concrete subclasses provide more strongly-typed return values for this method. Modifications to this buffer's content will cause the returned array's content to be modified, and vice versa. Invoke the `hasArray` method before invoking this method in order to ensure that this buffer has an accessible backing array. Returns:Object The array that backs this buffer Exceptions ReadOnlyBufferException: If this buffer is backed by an array but is read-only UnsupportedOperationException: If this buffer is not backed by an accessible array Since 1.6

public abstract Object array()

Returns the array that backs this buffer (optional operation).

This method is intended to allow array-backed buffers to be passed to native code more efficiently. Concrete subclasses provide more strongly-typed return values for this method.

Modifications to this buffer's content will cause the returned array's content to be modified, and vice versa.

Invoke the hasArray method before invoking this method in order to ensure that this buffer has an accessible backing array.

Returns:Object

The array that backs this buffer

Exceptions

ReadOnlyBufferException:: If this buffer is backed by an array but is read-only
UnsupportedOperationException:: If this buffer is not backed by an accessible array

Since

1.6

arrayOffset back to summary

arrayOffset	back to summary
public abstract int arrayOffset() Returns the offset within this buffer's backing array of the first element of the buffer (optional operation). If this buffer is backed by an array then buffer position p corresponds to array index p + `arrayOffset()`. Invoke the `hasArray` method before invoking this method in order to ensure that this buffer has an accessible backing array. Returns:int The offset within this buffer's array of the first element of the buffer Exceptions ReadOnlyBufferException: If this buffer is backed by an array but is read-only UnsupportedOperationException: If this buffer is not backed by an accessible array Since 1.6

public abstract int arrayOffset()

Returns the offset within this buffer's backing array of the first element of the buffer (optional operation).

If this buffer is backed by an array then buffer position p corresponds to array index p + arrayOffset().

Invoke the hasArray method before invoking this method in order to ensure that this buffer has an accessible backing array.

Returns:int

The offset within this buffer's array of the first element of the buffer

Exceptions

ReadOnlyBufferException:: If this buffer is backed by an array but is read-only
UnsupportedOperationException:: If this buffer is not backed by an accessible array

Since

1.6

base	back to summary
pack-priv abstract Object base() Returns:Object the base reference, paired with the address field, which in combination can be used for unsafe access into a heap buffer or direct byte buffer (and views of).

capacity	back to summary
public final int capacity() Returns this buffer's capacity. Returns:int The capacity of this buffer

capacity

back to summary

public final int capacity()

Returns this buffer's capacity.

Returns:int: The capacity of this buffer

checkIndex back to summary

checkIndex	back to summary
pack-priv final int checkIndex(int i) Checks the given index against the limit, throwing an `IndexOutOfBoundsException` if it is greater than the limit or is negative. Annotations @ForceInline

pack-priv final int checkIndex(int i)

Checks the given index against the limit, throwing an IndexOutOfBoundsException if it is greater than the limit or is negative.

Annotations

@ForceInline

checkIndex back to summary

checkIndex	back to summary
pack-priv final int checkIndex(int i, int nb) Checks the given index and number of bytes against the range `[0, limit]`, throwing an `IndexOutOfBoundsException` if the index is negative or the index plus the number of bytes is greater than the limit. Annotations @ForceInline

pack-priv final int checkIndex(int i, int nb)

Checks the given index and number of bytes against the range [0, limit], throwing an IndexOutOfBoundsException if the index is negative or the index plus the number of bytes is greater than the limit.

Annotations

@ForceInline

checkSession	back to summary
pack-priv final void checkSession()

clear back to summary

clear	back to summary
public Buffer clear() Clears this buffer. The position is set to zero, the limit is set to the capacity, and the mark is discarded. Invoke this method before using a sequence of channel-read or put operations to fill this buffer. For example: `buf.clear(); // Prepare buffer for reading in.read(buf); // Read data` buf.clear(); // Prepare buffer for reading in.read(buf); // Read data This method does not actually erase the data in the buffer, but it is named as if it did because it will most often be used in situations in which that might as well be the case. Returns:Buffer This buffer

public Buffer clear()

Clears this buffer. The position is set to zero, the limit is set to the capacity, and the mark is discarded.

Invoke this method before using a sequence of channel-read or put operations to fill this buffer. For example:

buf.clear();     // Prepare buffer for reading
in.read(buf);    // Read data

This method does not actually erase the data in the buffer, but it is named as if it did because it will most often be used in situations in which that might as well be the case.

Returns:Buffer: This buffer

createCapacityException back to summary

createCapacityException	back to summary
pack-priv static IllegalArgumentException createCapacityException(int capacity) Verify that the capacity is nonnegative. Parameters capacity:int The new buffer's capacity, in $type$s Exceptions IllegalArgumentException: If the `capacity` is a negative integer

pack-priv static IllegalArgumentException createCapacityException(int capacity)

Verify that the capacity is nonnegative.

Parameters

capacity:int: The new buffer's capacity, in $type$s

Exceptions

IllegalArgumentException:: If the capacity is a negative integer

createLimitException back to summary

createLimitException	back to summary
private IllegalArgumentException createLimitException(int newLimit) Verify that `0 < newLimit <= capacity` Parameters newLimit:int The new limit value Exceptions IllegalArgumentException: If the specified limit is out of bounds.

private IllegalArgumentException createLimitException(int newLimit)

Verify that 0 < newLimit <= capacity

Parameters

newLimit:int: The new limit value

Exceptions

IllegalArgumentException:: If the specified limit is out of bounds.

createPositionException back to summary

createPositionException	back to summary
private IllegalArgumentException createPositionException(int newPosition) Verify that `0 < newPosition <= limit` Parameters newPosition:int The new position value Exceptions IllegalArgumentException: If the specified position is out of bounds.

private IllegalArgumentException createPositionException(int newPosition)

Verify that 0 < newPosition <= limit

Parameters

newPosition:int: The new position value

Exceptions

IllegalArgumentException:: If the specified position is out of bounds.

createSameBufferException back to summary

createSameBufferException	back to summary
pack-priv static IllegalArgumentException createSameBufferException() Returns an `IllegalArgumentException` indicating that the source and target are the same `Buffer`. Intended for use in `put(src)` when the parameter is the `Buffer` on which the method is being invoked. Returns:IllegalArgumentException IllegalArgumentException With a message indicating equal source and target buffers

pack-priv static IllegalArgumentException createSameBufferException()

Returns an IllegalArgumentException indicating that the source and target are the same Buffer. Intended for use in put(src) when the parameter is the Buffer on which the method is being invoked.

Returns:IllegalArgumentException: IllegalArgumentException With a message indicating equal source and target buffers

discardMark	back to summary
pack-priv final void discardMark()

duplicate	back to summary
public abstract Buffer duplicate() Creates a new buffer that shares this buffer's content. The content of the new buffer will be that of this buffer. Changes to this buffer's content will be visible in the new buffer, and vice versa; the two buffers' position, limit, and mark values will be independent. The new buffer's capacity, limit, position and mark values will be identical to those of this buffer. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only. Returns:Buffer The new buffer Since 9

duplicate

back to summary

public abstract Buffer duplicate()

Creates a new buffer that shares this buffer's content.

The content of the new buffer will be that of this buffer. Changes to this buffer's content will be visible in the new buffer, and vice versa; the two buffers' position, limit, and mark values will be independent.

The new buffer's capacity, limit, position and mark values will be identical to those of this buffer. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.

Returns:Buffer: The new buffer
Since: 9

flip back to summary

flip	back to summary
public Buffer flip() Flips this buffer. The limit is set to the current position and then the position is set to zero. If the mark is defined then it is discarded. After a sequence of channel-read or put operations, invoke this method to prepare for a sequence of channel-write or relative get operations. For example: `buf.put(magic); // Prepend header in.read(buf); // Read data into rest of buffer buf.flip(); // Flip buffer out.write(buf); // Write header + data to channel` buf.put(magic); // Prepend header in.read(buf); // Read data into rest of buffer buf.flip(); // Flip buffer out.write(buf); // Write header + data to channel This method is often used in conjunction with the `compact` method when transferring data from one place to another. Returns:Buffer This buffer

public Buffer flip()

Flips this buffer. The limit is set to the current position and then the position is set to zero. If the mark is defined then it is discarded.

After a sequence of channel-read or put operations, invoke this method to prepare for a sequence of channel-write or relative get operations. For example:

buf.put(magic);    // Prepend header
in.read(buf);      // Read data into rest of buffer
buf.flip();        // Flip buffer
out.write(buf);    // Write header + data to channel

This method is often used in conjunction with the compact method when transferring data from one place to another.

Returns:Buffer: This buffer

hasArray back to summary

hasArray	back to summary
public abstract boolean hasArray() Tells whether or not this buffer is backed by an accessible array. If this method returns `true` then the `array` and `arrayOffset` methods may safely be invoked. Returns:boolean `true` if, and only if, this buffer is backed by an array and is not read-only Since 1.6

public abstract boolean hasArray()

Tells whether or not this buffer is backed by an accessible array.

If this method returns true then the array and arrayOffset methods may safely be invoked.

Returns:boolean: true if, and only if, this buffer is backed by an array and is not read-only
Since: 1.6

hasRemaining back to summary

hasRemaining	back to summary
public final boolean hasRemaining() Tells whether there are any elements between the current position and the limit. Returns:boolean `true` if, and only if, there is at least one element remaining in this buffer

public final boolean hasRemaining()

Tells whether there are any elements between the current position and the limit.

Returns:boolean: true if, and only if, there is at least one element remaining in this buffer

heapSegment	back to summary
pack-priv abstract AbstractMemorySegmentImpl heapSegment(Object base, long offset, long length, boolean readOnly, MemorySessionImpl bufferScope)

isDirect back to summary

isDirect	back to summary
public abstract boolean isDirect() Tells whether or not this buffer is direct. Returns:boolean `true` if, and only if, this buffer is direct Since 1.6

public abstract boolean isDirect()

Tells whether or not this buffer is direct.

Returns:boolean: true if, and only if, this buffer is direct
Since: 1.6

isReadOnly back to summary

isReadOnly	back to summary
public abstract boolean isReadOnly() Tells whether or not this buffer is read-only. Returns:boolean `true` if, and only if, this buffer is read-only

public abstract boolean isReadOnly()

Tells whether or not this buffer is read-only.

Returns:boolean: true if, and only if, this buffer is read-only

limit	back to summary
public final int limit() Returns this buffer's limit. Returns:int The limit of this buffer

limit

back to summary

public final int limit()

Returns this buffer's limit.

Returns:int: The limit of this buffer

limit back to summary

limit	back to summary
public Buffer limit(int newLimit) Sets this buffer's limit. If the position is larger than the new limit then it is set to the new limit. If the mark is defined and larger than the new limit then it is discarded. Parameters newLimit:int The new limit value; must be non-negative and no larger than this buffer's capacity Returns:Buffer This buffer Exceptions IllegalArgumentException: If the preconditions on `newLimit` do not hold

public Buffer limit(int newLimit)

Sets this buffer's limit. If the position is larger than the new limit then it is set to the new limit. If the mark is defined and larger than the new limit then it is discarded.

Parameters

newLimit:int: The new limit value; must be non-negative and no larger than this buffer's capacity

Returns:Buffer

This buffer

Exceptions

IllegalArgumentException:: If the preconditions on newLimit do not hold

mark	back to summary
public Buffer mark() Sets this buffer's mark at its position. Returns:Buffer This buffer

mark

back to summary

public Buffer mark()

Sets this buffer's mark at its position.

Returns:Buffer: This buffer

markValue	back to summary
pack-priv final int markValue()

nextGetIndex back to summary

nextGetIndex	back to summary
pack-priv final int nextGetIndex() Checks the current position against the limit, throwing a `BufferUnderflowException` if it is not smaller than the limit, and then increments the position. Returns:int The current position value, before it is incremented

pack-priv final int nextGetIndex()

Checks the current position against the limit, throwing a BufferUnderflowException if it is not smaller than the limit, and then increments the position.

Returns:int: The current position value, before it is incremented

nextGetIndex	back to summary
pack-priv final int nextGetIndex(int nb)

nextPutIndex back to summary

nextPutIndex	back to summary
pack-priv final int nextPutIndex() Checks the current position against the limit, throwing a `BufferOverflowException` if it is not smaller than the limit, and then increments the position. Returns:int The current position value, before it is incremented

pack-priv final int nextPutIndex()

Checks the current position against the limit, throwing a BufferOverflowException if it is not smaller than the limit, and then increments the position.

Returns:int: The current position value, before it is incremented

nextPutIndex	back to summary
pack-priv final int nextPutIndex(int nb)

position	back to summary
public final int position() Returns this buffer's position. Returns:int The position of this buffer

position

back to summary

public final int position()

Returns this buffer's position.

Returns:int: The position of this buffer

position back to summary

position	back to summary
public Buffer position(int newPosition) Sets this buffer's position. If the mark is defined and larger than the new position then it is discarded. Parameters newPosition:int The new position value; must be non-negative and no larger than the current limit Returns:Buffer This buffer Exceptions IllegalArgumentException: If the preconditions on `newPosition` do not hold

public Buffer position(int newPosition)

Sets this buffer's position. If the mark is defined and larger than the new position then it is discarded.

Parameters

newPosition:int: The new position value; must be non-negative and no larger than the current limit

Returns:Buffer

This buffer

Exceptions

IllegalArgumentException:: If the preconditions on newPosition do not hold

remaining	back to summary
public final int remaining() Returns the number of elements between the current position and the limit. Returns:int The number of elements remaining in this buffer

remaining

back to summary

public final int remaining()

Returns the number of elements between the current position and the limit.

Returns:int: The number of elements remaining in this buffer

reset	back to summary
public Buffer reset() Resets this buffer's position to the previously-marked position. Invoking this method neither changes nor discards the mark's value. Returns:Buffer This buffer Exceptions InvalidMarkException: If the mark has not been set

reset

back to summary

public Buffer reset()

Resets this buffer's position to the previously-marked position.

Invoking this method neither changes nor discards the mark's value.

Returns:Buffer

This buffer

Exceptions

InvalidMarkException:: If the mark has not been set

rewind back to summary

rewind	back to summary
public Buffer rewind() Rewinds this buffer. The position is set to zero and the mark is discarded. Invoke this method before a sequence of channel-write or get operations, assuming that the limit has already been set appropriately. For example: `out.write(buf); // Write remaining data buf.rewind(); // Rewind buffer buf.get(array); // Copy data into array` out.write(buf); // Write remaining data buf.rewind(); // Rewind buffer buf.get(array); // Copy data into array Returns:Buffer This buffer

public Buffer rewind()

Rewinds this buffer. The position is set to zero and the mark is discarded.

Invoke this method before a sequence of channel-write or get operations, assuming that the limit has already been set appropriately. For example:

out.write(buf);    // Write remaining data
buf.rewind();      // Rewind buffer
buf.get(array);    // Copy data into array

Returns:Buffer: This buffer

scaleShifts	back to summary
pack-priv abstract int scaleShifts() Returns the scale shifts for this Buffer. The scale shifts are: ByteBuffer: 0 ShortBuffer, CharBuffer: 1 IntBuffer, FloatBuffer: 2 LongBuffer, DoubleBuffer: 3 Returns:int the scale shifts for this Buffer

scaleShifts

back to summary

pack-priv abstract int scaleShifts()

Returns the scale shifts for this Buffer.

The scale shifts are: ByteBuffer: 0 ShortBuffer, CharBuffer: 1 IntBuffer, FloatBuffer: 2 LongBuffer, DoubleBuffer: 3

Returns:int: the scale shifts for this Buffer

session	back to summary
pack-priv final MemorySessionImpl session() Annotations @ForceInline

slice

back to summary

public abstract Buffer slice()

Creates a new buffer whose content is a shared subsequence of this buffer's content.

The content of the new buffer will start at this buffer's current position. Changes to this buffer's content will be visible in the new buffer, and vice versa; the two buffers' position, limit, and mark values will be independent.

The new buffer's position will be zero, its capacity and its limit will be the number of elements remaining in this buffer, its mark will be undefined. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.

Returns:Buffer: The new buffer
Since: 9

slice back to summary

public abstract Buffer slice(int index, int length)

Creates a new buffer whose content is a shared subsequence of this buffer's content.

The content of the new buffer will start at position index in this buffer, and will contain length elements. Changes to this buffer's content will be visible in the new buffer, and vice versa; the two buffers' position, limit, and mark values will be independent.

The new buffer's position will be zero, its capacity and its limit will be length, its mark will be undefined. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.

Parameters

index:int: The position in this buffer at which the content of the new buffer will start; must be non-negative and no larger than limit()
length:int: The number of elements the new buffer will contain; must be non-negative and no larger than limit() - index

Returns:Buffer

The new buffer

Exceptions

IndexOutOfBoundsException:: If index is negative or greater than limit(), length is negative, or length > limit() - index

Since

public abstract sealed Class Buffer

Transferring data

Marking and resetting

Invariants

Additional operations

Read-only buffers

Thread safety

Invocation chaining

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail