Spec-Zone .ru
спецификации, руководства, описания, API
|
public abstract class ByteBuffer extends Buffer implements Comparable<ByteBuffer>
Этот class определяет шесть категорий операций на буферы байта:
Абсолютный и относительный добраться
и
поместить
методы, которые читают и пишут единственные байты;
Родственник объем добирается
методы, которые передают непрерывные последовательности байтов от этого буфера в массив;
Родственник объем помещается
методы, которые передают непрерывные последовательности байтов от байтового массива или некоторого другого буфера байта в этот буфер;
Абсолютный и относительный добраться
и
поместить
методы, которые читают и пишут значения других типов примитивов, преобразовывая их в и от последовательностей байтов в определенном порядке байтов;
Методы для того, чтобы создать буферы представления, которые позволяют буферу байта просматриваться как буферное, содержащее значения некоторого другого типа примитива; и
Методы для уплотнение
,
дублирование
, и
разрезание
буфер байта.
Буферы байта могут быть созданы любой Буфер байта является или прямым или непрямым. Учитывая прямой буфер байта, виртуальная машина Java сделает максимальные усилия, чтобы выполнить собственные операции ввода-вывода непосредственно на это. Таким образом, это попытается избежать копировать контент буфера в (или от) промежуточный буфер прежде (или после) каждый вызов одной из собственных операций ввода-вывода базовой операционной системы. Прямой буфер байта может быть создан, вызывая Прямой буфер байта может также быть создан Является ли буфер байта прямым, или непрямой может быть определен, вызывая Этот class определяет методы для чтения и записи значений всех других типов примитивов, кроме boolean. Примитивные значения преобразовываются в (или от) последовательности байтов согласно текущему порядку байтов буфера, который может быть получен и изменен через Для доступа к неоднородным двоичным данным, то есть, последовательностям значений различных типов, этот class определяет семейство абсолютных, и относительные получают и помещают методы для каждого типа. Для 32-разрядных значений с плавающей точкой, например, этот class определяет: Соответствующие методы определяются для типов char, short, int, long, и double. Индексировать параметры абсолюта получают и помещают методы, с точки зрения байтов, а не типа, считанного или записанного.
Для доступа к гомогенным двоичным данным, то есть, последовательностям значений того же самого типа, этот class определяет методы, которые могут создать представления данного буфера байта. Буфер представления является просто другим буфером, контент которого поддерживается буфером байта. Изменения к буферному контенту байта будут видимы в буфере представления, и наоборот; позиция этих двух буферов, предел, и значения метки независимы. У буферов представления есть три важных преимущества перед семействами специфичных для типа, получают и помещают методы, описанные выше: Буфер представления индексируется не с точки зрения байтов, а скорее с точки зрения специфичного для типа размера его значений; Буфер представления обеспечивает, относительный объем получают и помещают методы, которые могут передать непрерывные последовательности значений между буфером и массивом или некоторым другим буфером того же самого типа; и Буфер представления потенциально намного более эффективен, потому что это будет прямым, если, и только если, его буфер байта поддержки является прямым. Порядок байтов буфера представления фиксируется, чтобы быть тем из его буфера байта в то время, когда представление создается. Методы в этом class, у которых иначе нет значения, чтобы возвратиться, определяются, чтобы возвратить буфер, на который они вызываются. Это позволяет вызовам метода быть объединенными в цепочку. Последовательность операторов выделение
, который выделяет место для контента буфера, или
обертывание
существующий байтовый массив в буфер.
Прямой по сравнению с непрямыми буферами
allocateDirect
метод фабрики этого class. У буферов, возвращенных этим методом обычно, есть несколько более высокое выделение и затраты освобождения чем непрямые буферы. Содержание прямых буферов может находиться за пределами нормальной собранной "мусор" "кучи", и таким образом, их воздействие на объем потребляемой памяти приложения не могло бы быть очевидным. Поэтому рекомендуется, чтобы прямые буферы были выделены прежде всего для больших, долговечных буферов, которые подвергаются собственным операциям ввода-вывода базовой системы. Вообще лучше выделять прямые буферы только, когда они приводят к усилению measureable в производительности программы. отображение
область файла непосредственно в память. Реализация платформы Java может дополнительно поддерживать создание прямых буферов байта из собственного кода через JNI. Если экземпляр одного из этих видов буферов обратится к недоступной области памяти тогда, то попытка получить доступ к той области не будет изменять контент буфера и заставит неуказанное исключение быть брошенным или во время доступа или в некоторое более позднее время.
isDirect
метод. Этот метод обеспечивается так, чтобы явная организация буферизации данных могла быть сделана в критическом по отношению к производительности коде.
Доступ к двоичным данным
order
методы. Определенные заказы байта представляются экземплярами ByteOrder
class. Начальный порядок буфера байта всегда BIG_ENDIAN
.
float
getFloat()
float getFloat(int index)
void putFloat(float f)
void putFloat(int index, float f)
asFloatBuffer
метод, например, создает экземпляр FloatBuffer
class, который поддерживается буфером байта, на который вызывается метод. Соответствующие методы создания представления определяются для типов char, short, int, long, и double.
Объединение в цепочку вызова
может, например, быть заменен единственным оператором
bb.putInt(0xCAFEBABE);
bb.putShort(3);
bb.putShort(45);
bb.putInt(0xCAFEBABE).putShort(3).putShort(45);
Модификатор и Тип | Метод и Описание |
---|---|
static ByteBuffer |
allocate(int capacity)
Выделяет новый буфер байта.
|
static ByteBuffer |
allocateDirect(int capacity)
Выделяет новый прямой буфер байта.
|
byte[] |
array()
Возвращает байтовый массив, который поддерживает этот буфер (дополнительная работа).
|
int |
arrayOffset()
Возвращает смещение в пределах массива поддержки этого буфера первого элемента буфера (дополнительная работа).
|
abstract CharBuffer |
asCharBuffer()
Создает представление этого буфера байта как буфер случайной работы.
|
abstract DoubleBuffer |
asDoubleBuffer()
Создает представление этого буфера байта как двойной буфер.
|
abstract FloatBuffer |
asFloatBuffer()
Создает представление этого буфера байта как буфер плавающий.
|
abstract IntBuffer |
asIntBuffer()
Создает представление этого буфера байта как международный буфер.
|
abstract LongBuffer |
asLongBuffer()
Создает представление этого буфера байта как длинный буфер.
|
abstract ByteBuffer |
asReadOnlyBuffer()
Создает новый, буфер байта только для чтения, который совместно использует контент этого буфера.
|
abstract ShortBuffer |
asShortBuffer()
Создает представление этого буфера байта как короткий буфер.
|
abstract ByteBuffer |
compact()
Уплотняет этот буфер (дополнительная работа).
|
int |
compareTo(ByteBuffer that)
Сравнивает этот буфер с другим.
|
abstract ByteBuffer |
duplicate()
Создает новый буфер байта, который совместно использует контент этого буфера.
|
boolean |
equals(Object ob)
Говорит, равен ли этот буфер другому объекту.
|
abstract byte |
get()
Родственник получает метод.
|
ByteBuffer |
get(byte[] dst)
Относительный объем получает метод.
|
ByteBuffer |
get(byte[] dst, int offset, int length)
Относительный объем получает метод.
|
abstract byte |
get(int index)
Абсолютный получают метод.
|
abstract char |
getChar()
Родственник получает метод для того, чтобы он считал значение случайной работы.
|
abstract char |
getChar(int index)
Абсолютный получают метод для того, чтобы он считал значение случайной работы.
|
abstract double |
getDouble()
Родственник получает метод для того, чтобы он считал двойное значение.
|
abstract double |
getDouble(int index)
Абсолютный получают метод для того, чтобы он считал двойное значение.
|
abstract float |
getFloat()
Родственник получает метод для того, чтобы он считал значение плавающее.
|
abstract float |
getFloat(int index)
Абсолютный получают метод для того, чтобы он считал значение плавающее.
|
abstract int |
getInt()
Родственник получает метод для того, чтобы он считал международное значение.
|
abstract int |
getInt(int index)
Абсолютный получают метод для того, чтобы он считал международное значение.
|
abstract long |
getLong()
Родственник получает метод для того, чтобы он считал длинное значение.
|
abstract long |
getLong(int index)
Абсолютный получают метод для того, чтобы он считал длинное значение.
|
abstract short |
getShort()
Родственник получает метод для того, чтобы он считал короткое значение.
|
abstract short |
getShort(int index)
Абсолютный получают метод для того, чтобы он считал короткое значение.
|
boolean |
hasArray()
Говорит, поддерживается ли этот буфер доступным байтовым массивом.
|
int |
hashCode()
Возвращает текущий хэш-код этого буфера.
|
abstract boolean |
isDirect()
Говорит, является ли этот буфер байта прямым.
|
ByteOrder |
order()
Получает порядок байтов этого буфера.
|
ByteBuffer |
order(ByteOrder bo)
Изменяет порядок байтов этого буфера.
|
abstract ByteBuffer |
put(byte b)
Родственник помещенный метод (дополнительная работа).
|
ByteBuffer |
put(byte[] src)
Относительный объем помещенный метод (дополнительная работа).
|
ByteBuffer |
put(byte[] src, int offset, int length)
Относительный объем помещенный метод (дополнительная работа).
|
ByteBuffer |
put(ByteBuffer src)
Относительный объем помещенный метод (дополнительная работа).
|
abstract ByteBuffer |
put(int index, byte b)
Абсолютный помещенный метод (дополнительная работа).
|
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)
Родственник помещенный метод для того, чтобы записать длинное значение (дополнительная работа).
|
abstract ByteBuffer |
putShort(int index, short value)
Абсолютный помещенный метод для того, чтобы записать короткое значение (дополнительная работа).
|
abstract ByteBuffer |
putShort(short value)
Родственник помещенный метод для того, чтобы записать короткое значение (дополнительная работа).
|
abstract ByteBuffer |
slice()
Создает новый буфер байта, контент которого является совместно используемой подпоследовательностью контента этого буфера.
|
Строка |
toString()
Возвращает строку, суммирующую состояние этого буфера.
|
static ByteBuffer |
wrap(byte[] array)
Обертывает байтовый массив в буфер.
|
static ByteBuffer |
wrap(byte[] array, int offset, int length)
Обертывает байтовый массив в буфер.
|
public static ByteBuffer allocateDirect(int capacity)
Позиция нового буфера будет нулем, его предел будет его емкостью, ее метка будет неопределена, и каждый из ее элементов будет инициализирован, чтобы обнулить. Есть ли у этого a поддержка массива
является неуказанным.
capacity
- Емкость нового буфера, в байтахIllegalArgumentException
- Если capacity является отрицательным целым числомpublic static ByteBuffer allocate(int capacity)
Позиция нового буфера будет нулем, его предел будет его емкостью, ее метка будет неопределена, и каждый из ее элементов будет инициализирован, чтобы обнулить. У этого будет a поддержка массива
, и
массив смещается
будет нуль.
capacity
- Емкость нового буфера, в байтахIllegalArgumentException
- Если capacity является отрицательным целым числомpublic static ByteBuffer wrap(byte[] array, int offset, int length)
Новый буфер будет поддержан данным байтовым массивом; то есть, модификации к буферу заставят массив быть измененным и наоборот. Емкостью нового буфера будет array.length, его позицией будет offset, его пределом будет offset + length, и его метка будет неопределена. поддержка массива
будет данный массив, и
массив смещается
будет нуль.
array
- Массив, который поддержит новый буферoffset
- Смещение подмассива, который будет использоваться; должно быть неотрицательным и не больше чем array.length. Позиция нового буфера будет установлена в это значение.length
- Длина подмассива, который будет использоваться; должно быть неотрицательным и не больше чем array.length - offset. Предел нового буфера будет установлен к offset + length.IndexOutOfBoundsException
- Если предварительные условия на offset и параметрах length не содержатpublic static ByteBuffer wrap(byte[] array)
Новый буфер будет поддержан данным байтовым массивом; то есть, модификации к буферу заставят массив быть измененным и наоборот. Емкостью нового буфера и пределом будет array.length, его позиция будет нулем, и его метка будет неопределена. поддержка массива
будет данный массив, и
массив смещается
будет нуль.
array
- Массив, который поддержит этот буферpublic abstract ByteBuffer slice()
Контент нового буфера запустится в текущей позиции этого буфера. Изменения к контенту этого буфера будут видимы в новом буфере, и наоборот; позиция этих двух буферов, предел, и значения метки будут независимы.
Позиция нового буфера будет нулем, его емкость и его предел будут числом байтов, остающихся в этом буфере, и его метка будет неопределена. Новый буфер будет прямым, если, и только если, этот буфер является прямым, и это будет только для чтения, если, и только если, этот буфер только для чтения.
public abstract ByteBuffer duplicate()
Контент нового буфера будет контентом этого буфера. Изменения к контенту этого буфера будут видимы в новом буфере, и наоборот; позиция этих двух буферов, предел, и значения метки будут независимы.
Емкость нового буфера, предел, позиция, и значения метки будут идентичны таковым из этого буфера. Новый буфер будет прямым, если, и только если, этот буфер является прямым, и это будет только для чтения, если, и только если, этот буфер только для чтения.
public abstract ByteBuffer asReadOnlyBuffer()
Контент нового буфера будет контентом этого буфера. Изменения к контенту этого буфера будут видимы в новом буфере; новый буфер непосредственно, однако, будет только для чтения и не будет позволять совместно используемому контенту быть измененным. Позиция этих двух буферов, предел, и значения метки будут независимы.
Емкость нового буфера, предел, позиция, и значения метки будут идентичны таковым из этого буфера.
Если этот буфер самостоятельно только для чтения тогда, этот метод ведет себя точно таким же образом как duplicate
метод.
public abstract byte get()
BufferUnderflowException
- Если текущая позиция буфера не меньше чем ее пределpublic abstract ByteBuffer put(byte b)
Пишет данный байт в этот буфер в текущей позиции, и затем постепенно увеличивает позицию.
b
- Байт, который будет записанBufferOverflowException
- Если текущая позиция этого буфера не меньше чем ее пределReadOnlyBufferException
- Если этот буфер только для чтенияpublic abstract byte get(int index)
index
- Индексирование, из которого будет считан байтIndexOutOfBoundsException
- Если index отрицателен или не меньше чем предел буфераpublic abstract ByteBuffer put(int index, byte b)
Пишет, что данный байт в этот буфер в данном индексирует.
index
- Индексирование, при котором будет записан байтb
- Значение байта, которое будет записаноIndexOutOfBoundsException
- Если index отрицателен или не меньше чем предел буфераReadOnlyBufferException
- Если этот буфер только для чтенияpublic ByteBuffer get(byte[] dst, int offset, int length)
Этот метод передает байты от этого буфера в данный целевой массив. Если есть меньше байтов, остающихся в буфере, чем обязаны удовлетворять запрос, то есть, если length > remaining(), то никакие байты не передаются и a BufferUnderflowException
бросается.
Иначе, этот метод копирует байты length с этого буфера в данный массив, запускающийся в текущей позиции этого буфера и при данном смещении в массиве. Позиция этого буфера тогда постепенно увеличивается length.
Другими словами вызов этого метода формы src.get(dst, off, len) имеет точно тот же самый эффект как цикл
for (int i = off; i < off + len; i++) dst[i] = src.get();except that it first checks that there are sufficient bytes in this buffer and it is potentially much more efficient.
dst
- The array into which bytes are to be writtenoffset
- The offset within the array of the first byte to be
written; must be non-negative and no larger than
dst.lengthlength
- The maximum number of bytes to be written to the given
array; must be non-negative and no larger than
dst.length - offsetBufferUnderflowException
- If there are fewer than length bytes
remaining in this bufferIndexOutOfBoundsException
- If the preconditions on the offset and length
parameters do not holdpublic ByteBuffer get(byte[] dst)
This method transfers bytes from this buffer into the given destination array. An invocation of this method of the form src.get(a) behaves in exactly the same way as the invocation
src.get(a, 0, a.length)
BufferUnderflowException
- If there are fewer than length bytes
remaining in this bufferpublic ByteBuffer put(ByteBuffer src)
This method transfers the bytes remaining in the given source
buffer into this buffer. If there are more bytes remaining in the
source buffer than in this buffer, that is, if
src.remaining() > remaining(),
then no bytes are transferred and a BufferOverflowException
is thrown.
Otherwise, this method copies n = src.remaining() bytes from the given buffer into this buffer, starting at each buffer's current position. The positions of both buffers are then incremented by n.
In other words, an invocation of this method of the form dst.put(src) has exactly the same effect as the loop
while (src.hasRemaining()) dst.put(src.get());except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
src
- The source buffer from which bytes are to be read;
must not be this bufferBufferOverflowException
- If there is insufficient space in this buffer
for the remaining bytes in the source bufferIllegalArgumentException
- If the source buffer is this bufferReadOnlyBufferException
- If this buffer is read-onlypublic ByteBuffer put(byte[] src, int offset, int length)
This method transfers bytes into this buffer from the given
source array. If there are more bytes to be copied from the array
than remain in this buffer, that is, if
length > remaining(), then no
bytes are transferred and a BufferOverflowException
is
thrown.
Otherwise, this method copies length bytes from the given array into this buffer, starting at the given offset in the array and at the current position of this buffer. The position of this buffer is then incremented by length.
In other words, an invocation of this method of the form dst.put(src, off, len) has exactly the same effect as the loop
for (int i = off; i < off + len; i++) dst.put(a[i]);except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
src
- The array from which bytes are to be readoffset
- The offset within the array of the first byte to be read;
must be non-negative and no larger than array.lengthlength
- The number of bytes to be read from the given array;
must be non-negative and no larger than
array.length - offsetBufferOverflowException
- If there is insufficient space in this bufferIndexOutOfBoundsException
- If the preconditions on the offset and length
parameters do not holdReadOnlyBufferException
- If this buffer is read-onlypublic final ByteBuffer put(byte[] src)
This method transfers the entire content of the given source byte array into this buffer. An invocation of this method of the form dst.put(a) behaves in exactly the same way as the invocation
dst.put(a, 0, a.length)
BufferOverflowException
- If there is insufficient space in this bufferReadOnlyBufferException
- If this buffer is read-onlypublic final boolean hasArray()
If this method returns true then the array
and arrayOffset
methods may safely be invoked.
public final byte[] array()
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.
array
in class Buffer
ReadOnlyBufferException
- If this buffer is backed by an array but is read-onlyUnsupportedOperationException
- If this buffer is not backed by an accessible arraypublic final int arrayOffset()
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.
arrayOffset
in class Buffer
ReadOnlyBufferException
- If this buffer is backed by an array but is read-onlyUnsupportedOperationException
- If this buffer is not backed by an accessible arraypublic abstract ByteBuffer compact()
The bytes between the buffer's current position and its limit, if any, are copied to the beginning of the buffer. That is, the byte at index p = position() is copied to index zero, the byte at index p + 1 is copied to index one, and so forth until the byte at index limit() - 1 is copied to index n = limit() - 1 - p. The buffer's position is then set to n+1 and its limit is set to its capacity. The mark, if defined, is discarded.
The buffer's position is set to the number of bytes copied, rather than to zero, so that an invocation of this method can be followed immediately by an invocation of another relative put method.
Invoke this method after writing data from a buffer in case the write was incomplete. The following loop, for example, copies bytes from one channel to another via the buffer buf:
buf.clear(); // Prepare buffer for use while (in.read(buf) >= 0 || buf.position != 0) { buf.flip(); out.write(buf); buf.compact(); // In case of partial write }
ReadOnlyBufferException
- If this buffer is read-onlypublic abstract boolean isDirect()
public String toString()
public int hashCode()
The hash code of a byte buffer depends only upon its remaining elements; that is, upon the elements from position() up to, and including, the element at limit() - 1.
Because buffer hash codes are content-dependent, it is inadvisable to use buffers as keys in hash maps or similar data structures unless it is known that their contents will not change.
hashCode
in class Object
Object.equals(java.lang.Object)
,
System.identityHashCode(java.lang.Object)
public boolean equals(Object ob)
Two byte buffers are equal if, and only if,
They have the same element type,
They have the same number of remaining elements, and
The two sequences of remaining elements, considered independently of their starting positions, are pointwise equal.
A byte buffer is not equal to any other type of object.
equals
in class Object
ob
- The object to which this buffer is to be comparedObject.hashCode()
,
HashMap
public int compareTo(ByteBuffer that)
Two byte buffers are compared by comparing their sequences of
remaining elements lexicographically, without regard to the starting
position of each sequence within its corresponding buffer.
Pairs of byte
elements are compared as if by invoking
Byte.compare(byte,byte)
.
A byte buffer is not comparable to any other type of object.
compareTo
in interface Comparable<ByteBuffer>
that
- the object to be compared.public final ByteOrder order()
The byte order is used when reading or writing multibyte values, and
when creating buffers that are views of this byte buffer. The order of
a newly-created byte buffer is always BIG_ENDIAN
.
public final ByteBuffer order(ByteOrder bo)
bo
- The new byte order,
either BIG_ENDIAN
or LITTLE_ENDIAN
public abstract char getChar()
Reads the next two bytes at this buffer's current position, composing them into a char value according to the current byte order, and then increments the position by two.
BufferUnderflowException
- If there are fewer than two bytes
remaining in this bufferpublic abstract ByteBuffer putChar(char value)
Writes two bytes containing the given char value, in the current byte order, into this buffer at the current position, and then increments the position by two.
value
- The char value to be writtenBufferOverflowException
- If there are fewer than two bytes
remaining in this bufferReadOnlyBufferException
- If this buffer is read-onlypublic abstract char getChar(int index)
Reads two bytes at the given index, composing them into a char value according to the current byte order.
index
- The index from which the bytes will be readIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus onepublic abstract ByteBuffer putChar(int index, char value)
Writes two bytes containing the given char value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The char value to be writtenIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus oneReadOnlyBufferException
- If this buffer is read-onlypublic abstract CharBuffer asCharBuffer()
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 bytes remaining in this buffer divided by two, and 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.
public abstract short getShort()
Reads the next two bytes at this buffer's current position, composing them into a short value according to the current byte order, and then increments the position by two.
BufferUnderflowException
- If there are fewer than two bytes
remaining in this bufferpublic abstract ByteBuffer putShort(short value)
Writes two bytes containing the given short value, in the current byte order, into this buffer at the current position, and then increments the position by two.
value
- The short value to be writtenBufferOverflowException
- If there are fewer than two bytes
remaining in this bufferReadOnlyBufferException
- If this buffer is read-onlypublic abstract short getShort(int index)
Reads two bytes at the given index, composing them into a short value according to the current byte order.
index
- The index from which the bytes will be readIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus onepublic abstract ByteBuffer putShort(int index, short value)
Writes two bytes containing the given short value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The short value to be writtenIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus oneReadOnlyBufferException
- If this buffer is read-onlypublic abstract ShortBuffer asShortBuffer()
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 bytes remaining in this buffer divided by two, and 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.
public abstract int getInt()
Reads the next four bytes at this buffer's current position, composing them into an int value according to the current byte order, and then increments the position by four.
BufferUnderflowException
- If there are fewer than four bytes
remaining in this bufferpublic abstract ByteBuffer putInt(int value)
Writes four bytes containing the given int value, in the current byte order, into this buffer at the current position, and then increments the position by four.
value
- The int value to be writtenBufferOverflowException
- If there are fewer than four bytes
remaining in this bufferReadOnlyBufferException
- If this buffer is read-onlypublic abstract int getInt(int index)
Reads four bytes at the given index, composing them into a int value according to the current byte order.
index
- The index from which the bytes will be readIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus threepublic abstract ByteBuffer putInt(int index, int value)
Writes four bytes containing the given int value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The int value to be writtenIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus threeReadOnlyBufferException
- If this buffer is read-onlypublic abstract IntBuffer asIntBuffer()
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 bytes remaining in this buffer divided by four, and 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.
public abstract long getLong()
Reads the next eight bytes at this buffer's current position, composing them into a long value according to the current byte order, and then increments the position by eight.
BufferUnderflowException
- If there are fewer than eight bytes
remaining in this bufferpublic abstract ByteBuffer putLong(long value)
Writes eight bytes containing the given long value, in the current byte order, into this buffer at the current position, and then increments the position by eight.
value
- The long value to be writtenBufferOverflowException
- If there are fewer than eight bytes
remaining in this bufferReadOnlyBufferException
- If this buffer is read-onlypublic abstract long getLong(int index)
Reads eight bytes at the given index, composing them into a long value according to the current byte order.
index
- The index from which the bytes will be readIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus sevenpublic abstract ByteBuffer putLong(int index, long value)
Writes eight bytes containing the given long value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The long value to be writtenIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus sevenReadOnlyBufferException
- If this buffer is read-onlypublic abstract LongBuffer asLongBuffer()
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 bytes remaining in this buffer divided by eight, and 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.
public abstract float getFloat()
Reads the next four bytes at this buffer's current position, composing them into a float value according to the current byte order, and then increments the position by four.
BufferUnderflowException
- If there are fewer than four bytes
remaining in this bufferpublic abstract ByteBuffer putFloat(float value)
Writes four bytes containing the given float value, in the current byte order, into this buffer at the current position, and then increments the position by four.
value
- The float value to be writtenBufferOverflowException
- If there are fewer than four bytes
remaining in this bufferReadOnlyBufferException
- If this buffer is read-onlypublic abstract float getFloat(int index)
Reads four bytes at the given index, composing them into a float value according to the current byte order.
index
- The index from which the bytes will be readIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus threepublic abstract ByteBuffer putFloat(int index, float value)
Writes four bytes containing the given float value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The float value to be writtenIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus threeReadOnlyBufferException
- If this buffer is read-onlypublic abstract FloatBuffer asFloatBuffer()
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 bytes remaining in this buffer divided by four, and 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.
public abstract double getDouble()
Reads the next eight bytes at this buffer's current position, composing them into a double value according to the current byte order, and then increments the position by eight.
BufferUnderflowException
- If there are fewer than eight bytes
remaining in this bufferpublic abstract ByteBuffer putDouble(double value)
Writes eight bytes containing the given double value, in the current byte order, into this buffer at the current position, and then increments the position by eight.
value
- The double value to be writtenBufferOverflowException
- If there are fewer than eight bytes
remaining in this bufferReadOnlyBufferException
- If this buffer is read-onlypublic abstract double getDouble(int index)
Reads eight bytes at the given index, composing them into a double value according to the current byte order.
index
- The index from which the bytes will be readIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus sevenpublic abstract ByteBuffer putDouble(int index, double value)
Writes eight bytes containing the given double value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The double value to be writtenIndexOutOfBoundsException
- If index is negative
or not smaller than the buffer's limit,
minus sevenReadOnlyBufferException
- If this buffer is read-onlypublic abstract DoubleBuffer asDoubleBuffer()
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 bytes remaining in this buffer divided by eight, and 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.
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2013, Oracle and/or its affiliates. All rights reserved.
DRAFT ea-b92