ByteBuffer (Платформа Java SE 7)

java.lang. Объект
- java.nio. Буфер
- - java.nio. ByteBuffer

Все Реализованные Интерфейсы:

Сопоставимый <ByteBuffer>

Прямые Известные Подклассы:

MappedByteBuffer
```
public abstract class ByteBuffer
extends Buffer
implements Comparable<ByteBuffer>
```
Буфер байта.
Этот класс определяет шесть категорий операций на буферы байта:
- Абсолютный и относительный добраться и поместить методы, которые читают и пишут единственные байты;
- Родственник объем добирается методы, которые передают непрерывные последовательности байтов от этого буфера в массив;
- Родственник объем помещается методы, которые передают непрерывные последовательности байтов от байтового массива или некоторого другого буфера байта в этот буфер;
- Абсолютный и относительный добраться и поместить методы, которые читают и пишут значения других типов примитивов, преобразовывая их в и от последовательностей байтов в определенном порядке байтов;
- Методы для того, чтобы создать буферы представления, которые позволяют буферу байта просматриваться как буферное, содержащее значения некоторого другого типа примитива; и
- Методы для уплотнение, дублирование, и разрезание буфер байта.
Буферы байта могут быть созданы любой выделение, который выделяет место для контента буфера, или обертывание существующий байтовый массив в буфер.
Прямой по сравнению с непрямыми буферами

Буфер байта является или прямым или непрямым. Учитывая прямой буфер байта, виртуальная машина Java сделает максимальные усилия, чтобы выполнить собственные операции ввода-вывода непосредственно на это. Таким образом, это попытается избежать копировать контент буфера в (или от) промежуточный буфер прежде (или после) каждый вызов одной из собственных операций ввода-вывода базовой операционной системы.
Прямой буфер байта может быть создан, вызывая allocateDirect метод фабрики этого класса. У буферов, возвращенных этим методом обычно, есть несколько более высокое выделение и затраты освобождения чем непрямые буферы. Содержание прямых буферов может находиться за пределами нормальной собранной "мусор" "кучи", и таким образом, их воздействие на место памяти приложения не могло бы быть очевидным. Поэтому рекомендуется, чтобы прямые буферы были выделены прежде всего для больших, долговечных буферов, которые подвергаются собственным операциям ввода-вывода базовой системы. Вообще лучше выделять прямые буферы только, когда они приводят к усилению measureable в производительности программы.
Прямой буфер байта может также быть создан отображение область файла непосредственно в память. Реализация платформы Java может дополнительно поддерживать создание прямых буферов байта от собственного кода через JNI. Если экземпляр одного из этих видов буферов обратится к недоступной области памяти тогда, то попытка получить доступ к той области не будет изменять контент буфера и заставит неуказанное исключение быть брошенным или во время доступа или в некоторое более позднее время.
Является ли буфер байта прямым, или непрямой может быть определен, вызывая isDirect метод. Этот метод обеспечивается так, чтобы явная организация буферизации данных могла быть сделана в критическом по отношению к производительности коде.
Доступ к двоичным данным

Этот класс определяет методы для чтения и записи значений всех других типов примитивов, кроме boolean. Примитивные значения преобразовываются в (или от) последовательности байтов согласно текущему порядку байтов буфера, который может быть получен и изменен через order методы. Определенные заказы байта представляются экземплярами ByteOrder класс. Начальный порядок буфера байта всегда BIG_ENDIAN.
Для доступа к неоднородным двоичным данным, то есть, последовательностям значений различных типов, этот класс определяет семейство абсолютных, и относительные получают и помещают методы для каждого типа. Для 32-разрядных значений с плавающей точкой, например, этот класс определяет:
```
 float  getFloat()
 float  getFloat(int index)
  void  putFloat(float f)
  void  putFloat(int index, float f)
```
Соответствующие методы определяются для типов char, short, int, long, и double. Индексные параметры абсолюта получают и помещают методы, с точки зрения байтов, а не типа, считанного или записанного.
Для доступа к гомогенным двоичным данным, то есть, последовательностям значений того же самого типа, этот класс определяет методы, которые могут создать представления данного буфера байта. Буфер представления является просто другим буфером, контент которого поддерживается буфером байта. Изменения к буферному контенту байта будут видимы в буфере представления, и наоборот; позиция этих двух буферов, предел, и значения метки независимы. asFloatBuffer метод, например, создает экземпляр FloatBuffer класс, который поддерживается буфером байта, на который вызывается метод. Соответствующие методы создания представления определяются для типов char, short, int, long, и double.
У буферов представления есть три важных преимущества перед семействами специфичных для типа, получают и помещают методы, описанные выше:
- Буфер представления индексируется не с точки зрения байтов, а скорее с точки зрения специфичного для типа размера его значений;
- Буфер представления обеспечивает, относительный объем получают и помещают методы, которые могут передать непрерывные последовательности значений между буфером и массивом или некоторым другим буфером того же самого типа; и
- Буфер представления потенциально намного более эффективен, потому что это будет прямым, если, и только если, его буфер байта поддержки является прямым.
Порядок байтов буфера представления фиксируется, чтобы быть тем из его буфера байта в то время, когда представление создается.

Объединение в цепочку вызова

Методы в этом классе, у которых иначе нет значения, чтобы возвратиться, определяются, чтобы возвратить буфер, на который они вызываются. Это позволяет вызовам метода быть объединенными в цепочку. Последовательность операторов
```
 bb.putInt(0xCAFEBABE);
 bb.putShort(3);
 bb.putShort(45);
```
может, например, быть заменен единственным оператором
```
 bb.putInt(0xCAFEBABE).putShort(3).putShort(45);
```
С тех пор:

1.4

Сводка метода

Методы
Модификатор и Тип	Метод и Описание
`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)` Обертывает байтовый массив в буфер.

Методы java.nio унаследованный от класса. Буфер
capacity, clear, flip, hasRemaining, isReadOnly, limit, limit, mark, position, position, remaining, reset, rewind

Методы java.lang унаследованный от класса. Объект
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Деталь метода
  - allocateDirect
```
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()
```
    Создает новый буфер байта, который совместно использует контент этого буфера.
    Контент нового буфера будет контентом этого буфера. Изменения к контенту этого буфера будут видимы в новом буфере, и наоборот; позиция этих двух буферов, предел, и значения метки будут независимы.
    Емкость нового буфера, предел, позиция, и значения метки будут идентичны таковым из этого буфера. Новый буфер будет прямым, если, и только если, этот буфер является прямым, и это будет только для чтения, если, и только если, этот буфер только для чтения.
    
    Возвраты:
    Новый буфер байта
  - asReadOnlyBuffer
```
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.
    Parameters:
    dst - The array into which bytes are to be written
    offset - The offset within the array of the first byte to be written; must be non-negative and no larger than dst.length
    length - The maximum number of bytes to be written to the given array; must be non-negative and no larger than dst.length - offset
    
    Returns:
    This buffer
    
    Throws:
    
    BufferUnderflowException - If there are fewer than length bytes remaining in this buffer
    
    IndexOutOfBoundsException - If the preconditions on the offset and length parameters do not hold
  - get
```
public ByteBuffer get(byte[] dst)
```
    Relative bulk get method.
    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) 
```
    Returns:
    This buffer
    
    Throws:
    
    BufferUnderflowException - If there are fewer than length bytes remaining in this buffer
  - put
```
public ByteBuffer put(ByteBuffer src)
```
    Relative bulk put method (optional operation).
    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.
    Parameters:
    src - The source buffer from which bytes are to be read; must not be this buffer
    
    Returns:
    This buffer
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in this buffer for the remaining bytes in the source buffer
    
    IllegalArgumentException - If the source buffer is this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - put
```
public ByteBuffer put(byte[] src,
             int offset,
             int length)
```
    Relative bulk put method (optional operation).
    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.
    Parameters:
    src - The array from which bytes are to be read
    offset - The offset within the array of the first byte to be read; must be non-negative and no larger than array.length
    length - The number of bytes to be read from the given array; must be non-negative and no larger than array.length - offset
    
    Returns:
    This buffer
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in this buffer
    
    IndexOutOfBoundsException - If the preconditions on the offset and length parameters do not hold
    
    ReadOnlyBufferException - If this buffer is read-only
  - put
```
public final ByteBuffer put(byte[] src)
```
    Relative bulk put method (optional operation).
    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) 
```
    Returns:
    This buffer
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - hasArray
```
public final boolean hasArray()
```
    Tells whether or not this buffer is backed by an accessible byte array.
    If this method returns true then the array and arrayOffset methods may safely be invoked.
    
    Specified by:
    
    hasArray in class Buffer
    
    Returns:
    true if, and only if, this buffer is backed by an array and is not read-only
  - array
```
public final byte[] array()
```
    Returns the byte array that backs this buffer (optional operation).
    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.
    
    Specified by:
    
    array in class Buffer
    
    Returns:
    The array that backs this buffer
    
    Throws:
    
    ReadOnlyBufferException - If this buffer is backed by an array but is read-only
    
    UnsupportedOperationException - If this buffer is not backed by an accessible array
  - arrayOffset
```
public final 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.
    
    Specified by:
    
    arrayOffset in class Buffer
    
    Returns:
    The offset within this buffer's array of the first element of the buffer
    
    Throws:
    
    ReadOnlyBufferException - If this buffer is backed by an array but is read-only
    
    UnsupportedOperationException - If this buffer is not backed by an accessible array
  - compact
```
public abstract ByteBuffer compact()
```
    Compacts this buffer (optional operation).
    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 }
    Returns:
    This buffer
    
    Throws:
    
    ReadOnlyBufferException - If this buffer is read-only
  - isDirect
```
public abstract boolean isDirect()
```
    Tells whether or not this byte buffer is direct.
    
    Specified by:
    
    isDirect in class Buffer
    
    Returns:
    true if, and only if, this buffer is direct
  - toString
```
public String toString()
```
    Returns a string summarizing the state of this buffer.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    A summary string
  - hashCode
```
public int hashCode()
```
    Returns the current hash code of this buffer.
    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.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    The current hash code of this buffer
    See Also:
    Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)
  - equals
```
public boolean equals(Object ob)
```
    Tells whether or not this buffer is equal to another object.
    Two byte buffers are equal if, and only if,
    1. They have the same element type,
    2. They have the same number of remaining elements, and
    3. 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.
    Overrides:
    
    equals in class Object
    
    Parameters:
    ob - The object to which this buffer is to be compared
    
    Returns:
    true if, and only if, this buffer is equal to the given object
    See Also:
    Object.hashCode(), HashMap
  - compareTo
```
public int compareTo(ByteBuffer that)
```
    Compares this buffer to another.
    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.
    
    Specified by:
    
    compareTo in interface Comparable<ByteBuffer>
    
    Parameters:
    that - the object to be compared.
    
    Returns:
    A negative integer, zero, or a positive integer as this buffer is less than, equal to, or greater than the given buffer
  - order
```
public final ByteOrder order()
```
    Retrieves this buffer's byte 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.
    
    Returns:
    This buffer's byte order
  - order
```
public final ByteBuffer order(ByteOrder bo)
```
    Modifies this buffer's byte order.
    
    Parameters:
    bo - The new byte order, either BIG_ENDIAN or LITTLE_ENDIAN
    
    Returns:
    This buffer
  - getChar
```
public abstract char getChar()
```
    Relative get method for reading a char value.
    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.
    
    Returns:
    The char value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than two bytes remaining in this buffer
  - putChar
```
public abstract ByteBuffer putChar(char value)
```
    Relative put method for writing a char value (optional operation).
    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.
    
    Parameters:
    value - The char value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than two bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getChar
```
public abstract char getChar(int index)
```
    Absolute get method for reading a char value.
    Reads two bytes at the given index, composing them into a char value according to the current byte order.
    
    Parameters:
    index - The index from which the bytes will be read
    
    Returns:
    The char value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus one
  - putChar
```
public abstract ByteBuffer putChar(int index,
                 char value)
```
    Absolute put method for writing a char value (optional operation).
    Writes two bytes containing the given char value, in the current byte order, into this buffer at the given index.
    
    Parameters:
    index - The index at which the bytes will be written
    value - The char value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus one
    
    ReadOnlyBufferException - If this buffer is read-only
  - asCharBuffer
```
public abstract CharBuffer asCharBuffer()
```
    Creates a view of this byte buffer as a char buffer.
    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.
    
    Returns:
    A new char buffer
  - getShort
```
public abstract short getShort()
```
    Relative get method for reading a short value.
    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.
    
    Returns:
    The short value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than two bytes remaining in this buffer
  - putShort
```
public abstract ByteBuffer putShort(short value)
```
    Relative put method for writing a short value (optional operation).
    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.
    
    Parameters:
    value - The short value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than two bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getShort
```
public abstract short getShort(int index)
```
    Absolute get method for reading a short value.
    Reads two bytes at the given index, composing them into a short value according to the current byte order.
    
    Parameters:
    index - The index from which the bytes will be read
    
    Returns:
    The short value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus one
  - putShort
```
public abstract ByteBuffer putShort(int index,
                  short value)
```
    Absolute put method for writing a short value (optional operation).
    Writes two bytes containing the given short value, in the current byte order, into this buffer at the given index.
    
    Parameters:
    index - The index at which the bytes will be written
    value - The short value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus one
    
    ReadOnlyBufferException - If this buffer is read-only
  - asShortBuffer
```
public abstract ShortBuffer asShortBuffer()
```
    Creates a view of this byte buffer as a short buffer.
    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.
    
    Returns:
    A new short buffer
  - getInt
```
public abstract int getInt()
```
    Relative get method for reading an int value.
    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.
    
    Returns:
    The int value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than four bytes remaining in this buffer
  - putInt
```
public abstract ByteBuffer putInt(int value)
```
    Relative put method for writing an int value (optional operation).
    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.
    
    Parameters:
    value - The int value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than four bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getInt
```
public abstract int getInt(int index)
```
    Absolute get method for reading an int value.
    Reads four bytes at the given index, composing them into a int value according to the current byte order.
    
    Parameters:
    index - The index from which the bytes will be read
    
    Returns:
    The int value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus three
  - putInt
```
public abstract ByteBuffer putInt(int index,
                int value)
```
    Absolute put method for writing an int value (optional operation).
    Writes four bytes containing the given int value, in the current byte order, into this buffer at the given index.
    
    Parameters:
    index - The index at which the bytes will be written
    value - The int value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus three
    
    ReadOnlyBufferException - If this buffer is read-only
  - asIntBuffer
```
public abstract IntBuffer asIntBuffer()
```
    Creates a view of this byte buffer as an int buffer.
    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.
    
    Returns:
    A new int buffer
  - getLong
```
public abstract long getLong()
```
    Relative get method for reading a long value.
    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.
    
    Returns:
    The long value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than eight bytes remaining in this buffer
  - putLong
```
public abstract ByteBuffer putLong(long value)
```
    Relative put method for writing a long value (optional operation).
    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.
    
    Parameters:
    value - The long value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than eight bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getLong
```
public abstract long getLong(int index)
```
    Absolute get method for reading a long value.
    Reads eight bytes at the given index, composing them into a long value according to the current byte order.
    
    Parameters:
    index - The index from which the bytes will be read
    
    Returns:
    The long value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus seven
  - putLong
```
public abstract ByteBuffer putLong(int index,
                 long value)
```
    Absolute put method for writing a long value (optional operation).
    Writes eight bytes containing the given long value, in the current byte order, into this buffer at the given index.
    
    Parameters:
    index - The index at which the bytes will be written
    value - The long value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus seven
    
    ReadOnlyBufferException - If this buffer is read-only
  - asLongBuffer
```
public abstract LongBuffer asLongBuffer()
```
    Creates a view of this byte buffer as a long buffer.
    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.
    
    Returns:
    A new long buffer
  - getFloat
```
public abstract float getFloat()
```
    Relative get method for reading a float value.
    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.
    
    Returns:
    The float value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than four bytes remaining in this buffer
  - putFloat
```
public abstract ByteBuffer putFloat(float value)
```
    Relative put method for writing a float value (optional operation).
    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.
    
    Parameters:
    value - The float value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than four bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getFloat
```
public abstract float getFloat(int index)
```
    Absolute get method for reading a float value.
    Reads four bytes at the given index, composing them into a float value according to the current byte order.
    
    Parameters:
    index - The index from which the bytes will be read
    
    Returns:
    The float value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus three
  - putFloat
```
public abstract ByteBuffer putFloat(int index,
                  float value)
```
    Absolute put method for writing a float value (optional operation).
    Writes four bytes containing the given float value, in the current byte order, into this buffer at the given index.
    
    Parameters:
    index - The index at which the bytes will be written
    value - The float value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus three
    
    ReadOnlyBufferException - If this buffer is read-only
  - asFloatBuffer
```
public abstract FloatBuffer asFloatBuffer()
```
    Creates a view of this byte buffer as a float buffer.
    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.
    
    Returns:
    A new float buffer
  - getDouble
```
public abstract double getDouble()
```
    Relative get method for reading a double value.
    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.
    
    Returns:
    The double value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than eight bytes remaining in this buffer
  - putDouble
```
public abstract ByteBuffer putDouble(double value)
```
    Relative put method for writing a double value (optional operation).
    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.
    
    Parameters:
    value - The double value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than eight bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getDouble
```
public abstract double getDouble(int index)
```
    Absolute get method for reading a double value.
    Reads eight bytes at the given index, composing them into a double value according to the current byte order.
    
    Parameters:
    index - The index from which the bytes will be read
    
    Returns:
    The double value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus seven
  - putDouble
```
public abstract ByteBuffer putDouble(int index,
                   double value)
```
    Absolute put method for writing a double value (optional operation).
    Writes eight bytes containing the given double value, in the current byte order, into this buffer at the given index.
    
    Parameters:
    index - The index at which the bytes will be written
    value - The double value to be written
    
    Returns:
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus seven
    
    ReadOnlyBufferException - If this buffer is read-only
  - asDoubleBuffer
```
public abstract DoubleBuffer asDoubleBuffer()
```
    Creates a view of this byte buffer as a double buffer.
    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.
    
    Returns:
    A new double buffer

Представьте ошибку или функцию
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, 2011, Oracle and/or its affiliates. All rights reserved.

Класс ByteBuffer

Прямой по сравнению с непрямыми буферами

Доступ к двоичным данным

Объединение в цепочку вызова

Сводка метода

Методы java.nio унаследованный от класса. Буфер

Методы java.lang унаследованный от класса. Объект

Деталь метода

allocateDirect

выделить

обертка

обертка

часть

копия

asReadOnlyBuffer

добраться

поместить

добраться

поместить

добраться

get

put

put

put

hasArray

array

arrayOffset

compact

isDirect

toString

hashCode

equals

compareTo

order

order

getChar

putChar

getChar

putChar

asCharBuffer

getShort

putShort

getShort

putShort

asShortBuffer

getInt

putInt

getInt

putInt

asIntBuffer

getLong

putLong

getLong

putLong

asLongBuffer

getFloat

putFloat

getFloat

putFloat

asFloatBuffer

getDouble

putDouble

getDouble

putDouble

asDoubleBuffer