Класс FloatBuffer

Все реализованные интерфейсы:
Comparable<FloatBuffer>
public abstract class FloatBuffer
extends Buffer
implements Comparable<FloatBuffer>

Буфер с плавающей точкой.

Этот класс определяет четыре категории операций над буферами с плавающей точкой:

  • Абсолютные и относительные методы get и put, которые считывают и записывают отдельные значения с плавающей точкой;

  • Относительные методы bulk get, которые копируют непрерывные последовательности значений с плавающей точкой из этого буфера в массив;

  • Относительные методы bulk put, которые копируют непрерывные последовательности значений с плавающей точкой из массива с плавающей точкой или из другого буфера с плавающей точкой в этот буфер;

  • Метод для compacting буфера с плавающей точкой.

Буферы с плавающей точкой могут быть созданы либо с помощью allocation, который выделяет место для содержимого буфера, либо с помощью wrapping существующего массива значений с плавающей точкой в буфер, либо путем создания представления существующего буфера байтов.

Как и буфер байтов, буфер с плавающей точкой может быть прямым или непрямым. Буфер с плавающей точкой, созданный с помощью методов wrap этого класса, будет непрямым. Буфер с плавающей точкой, созданный как представление буфера байтов, будет прямым только в том случае, если сам буфер байтов является прямым. Можно определить, является ли буфер с плавающей точкой прямым, вызвав метод isDirect.

Методы в этом классе, которые не возвращают значение, явно возвращают буфер, на котором они вызваны. Это позволяет цеплять вызовы методов.

С:
1.4

Методы

Модификатор и тип Метод Описание
static FloatBuffer allocate​(int capacity)

Выделяет новый буфер с плавающей точкой.
float[] array()

Возвращает массив значений с плавающей точкой, на котором основан этот буфер (необязательная операция).
int arrayOffset()

Возвращает смещение в массиве, на котором основан этот буфер, первого элемента буфера (необязательная операция).
abstract FloatBuffer asReadOnlyBuffer()

Создает новый, только для чтения, буфер с плавающей точкой, который разделяет содержимое этого буфера.
abstract FloatBuffer compact()

Уплотняет этот буфер (необязательная операция).
int compareTo​(FloatBuffer that)

Сравнивает этот буфер с другим.
abstract FloatBuffer duplicate()

Создает новый буфер с плавающей точкой, который разделяет содержимое этого буфера.
boolean equals​(Object ob)

Определяет, равен ли этот буфер другому объекту.
abstract float get()

Относительный метод get.
FloatBuffer get​(float[] dst)

Относительный метод пакетного get.
FloatBuffer get​(float[] dst, int offset, int length)

Относительный метод пакетного get.
abstract float get​(int index)

Абсолютный метод get.
boolean hasArray()

Определяет, поддерживает ли этот буфер доступный массив значений с плавающей точкой.
int hashCode()

Возвращает текущий хэш-код этого буфера.
abstract boolean isDirect()

Определяет, является ли этот буфер с плавающей точкой прямым.
int mismatch​(FloatBuffer that)

Находит и возвращает относительный индекс первого несовпадения между этим буфером и заданным буфером.
abstract ByteOrder order()

Получает порядок байтов этого буфера.
abstract FloatBuffer put​(float f)

Относительный метод put (необязательная операция).
FloatBuffer put​(float[] src)

Относительный метод пакетного put (необязательная операция).
FloatBuffer put​(float[] src, int offset, int length)

Относительный метод пакетного put (необязательная операция).
abstract FloatBuffer put​(int index, float f)

Абсолютный метод put (необязательная операция).
FloatBuffer put​(FloatBuffer src)

Относительный метод пакетного put (необязательная операция).
abstract FloatBuffer slice()

Создает новый буфер с плавающей точкой, содержимое которого является общим подпоследовательностью содержимого этого буфера.
String toString()

Возвращает строку, описывающую состояние этого буфера.
static FloatBuffer wrap​(float[] array)

Преобразует массив значений с плавающей точкой в буфер.
static FloatBuffer wrap​(float[] array, int offset, int length)

Преобразует массив значений с плавающей точкой в буфер.

Методы, унаследованные от класса java.nio.Buffer

capacity, clear, flip, hasRemaining, isReadOnly, limit, limit, mark, position, position, remaining, reset, rewind

Методы, унаследованные от класса java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Методы

allocate

public static FloatBuffer allocate(int capacity)

Выделяет новый буфер с плавающей запятой.

Положение нового буфера будет равно нулю, его предел — его емкость, метка будет неопределенной, каждый его элемент будет инициализирован нулем, а порядок байтов — native order базового оборудования. У него будет backing array, и его array offset будет равен нулю.

Параметры:
capacity — емкость нового буфера в числах с плавающей запятой
Возвращает:
Новый буфер с плавающей запятой
Исключение:
IllegalArgumentException — если емкость является отрицательным целым числом

wrap

public static FloatBuffer wrap(float[] array,
                               int offset,
                               int length)

Оборачивает массив чисел с плавающей запятой в буфер.

Новый буфер будет опираться на заданный массив чисел с плавающей запятой; то есть изменения в буфере приведут к изменению массива и наоборот. Емкость нового буфера будет array.length, его положение — offset, его предел — offset + length, его метка — неопределенная, а порядок байтов — native order базового оборудования. Его backing array будет заданным массивом, а его array offset — нулём.

Параметры:
array — массив, который будет поддерживать новый буфер
offset — смещение подмассива для использования; должно быть неотрицательным и не больше array.length. Положение нового буфера будет установлено в это значение.
length — длина подмассива для использования; должна быть неотрицательной и не больше array.length - offset. Предел нового буфера будет установлен в offset + length.
Возвращает:
Новый буфер с плавающей запятой
Исключение:
IndexOutOfBoundsException — если условия для offset и length параметров не выполняются

wrap

public static FloatBuffer wrap(float[] array)

Оборачивает массив чисел с плавающей запятой в буфер.

Новый буфер будет опираться на заданный массив чисел с плавающей запятой; то есть изменения в буфере приведут к изменению массива и наоборот. Емкость и предел нового буфера будут array.length, его положение — нулём, его метка — неопределённой, а порядок байтов — native order базового оборудования. Его backing array будет заданным массивом, а его array offset — нулём.

Параметры:
array — массив, который будет поддерживать этот буфер
Возвращает:
Новый буфер с плавающей запятой

slice

public abstract FloatBuffer slice()

Создаёт новый буфер с плавающей запятой, содержимое которого является общим подпоследовательностью содержимого этого буфера.

Содержимое нового буфера начнётся с текущего положения этого буфера. Изменения в содержимом этого буфера будут видны в новом буфере, и наоборот; значения позиции, предела и метки двух буферов будут независимы.

Положение нового буфера будет равно нулю, его емкость и предел будут равны числу чисел с плавающей запятой, оставшихся в этом буфере, его метка будет неопределённой, а порядок байтов — идентичен порядку байтов этого буфера. Новый буфер будет прямым тогда и только тогда, когда этот буфер является прямым, и он будет только для чтения, если и только если этот буфер является только для чтения.

Указано в:
slice в классе Buffer
Возвращает:
Новый буфер с плавающей запятой

duplicate

public abstract FloatBuffer duplicate()

Создаёт новый буфер с плавающей запятой, который совместно использует содержимое этого буфера.

Содержимое нового буфера будет таким же, как у этого буфера. Изменения в содержимом этого буфера будут видны в новом буфере, и наоборот; значения позиции, предела и метки двух буферов будут независимыми.

Емкость, предел, положение, значения метки и порядок байтов нового буфера будут идентичны значениям этого буфера. Новый буфер будет прямым тогда и только тогда, когда этот буфер является прямым, и он будет только для чтения, если и только если этот буфер является только для чтения.

Указано в:
duplicate в классе Buffer
Возвращает:
Новый буфер с плавающей запятой

asReadOnlyBuffer

public abstract FloatBuffer asReadOnlyBuffer()

Создаёт новый, только для чтения буфер с плавающей запятой, который совместно использует содержимое этого буфера.

Содержимое нового буфера будет таким же, как у этого буфера. Изменения в содержимом этого буфера будут видны в новом буфере; однако сам новый буфер будет только для чтения и не позволит изменять совместно используемое содержимое. Значения позиции, предела и метки двух буферов будут независимыми.

Емкость, предел, положение, значения метки и порядок байтов нового буфера будут идентичны значениям этого буфера.

Если этот буфер сам по себе является только для чтения, то этот метод ведёт себя точно так же, как метод duplicate.

Возвращает:
Новый буфер с плавающей запятой, только для чтения

get

public abstract float get()

Относительный метод get. Считывает число с плавающей запятой в текущем положении буфера и затем увеличивает позицию.

Возвращает:
Число с плавающей запятой в текущем положении буфера
Исключение:
BufferUnderflowException — если текущее положение буфера не меньше его предела

put

public abstract FloatBuffer put(float f)

Относительный метод put (необязательная операция).

Записывает заданное число с плавающей запятой в этот буфер по текущему положению и затем увеличивает позицию.

Параметры:
f — число с плавающей запятой для записи
Возвращает:
Этот буфер
Исключение:
BufferOverflowException — если текущее положение этого буфера не меньше его предела
ReadOnlyBufferException — если этот буфер только для чтения

get

public abstract float get(int index)

Абсолютный метод get. Считывает число с плавающей запятой по заданному индексу.

Параметры:
index — индекс, с которого будет считываться число с плавающей запятой
Возвращает:
Число с плавающей запятой по заданному индексу
Исключение:
IndexOutOfBoundsException — если index отрицателен или не меньше предела буфера

put

public abstract FloatBuffer put(int index,
                                float f)

Абсолютный метод put (необязательная операция).

Записывает заданное число с плавающей запятой в этот буфер по заданному индексу.

Параметры:
index — индекс, по которому будет записываться число с плавающей запятой
f — значение числа с плавающей запятой для записи
Возвращает:
Этот буфер
Исключение:
IndexOutOfBoundsException — если index отрицателен или не меньше предела буфера
ReadOnlyBufferException — если этот буфер только для чтения

get

public FloatBuffer get(float[] dst,
                       int offset,
                       int length)

Относительный метод get для блоковой передачи.

Этот метод передает числа с плавающей запятой из этого буфера в заданный массив-приемник. Если в буфере остаётся меньше чисел с плавающей запятой, чем требуется для удовлетворения запроса, то есть, если length > remaining(), то числа с плавающей запятой не передаются, и выбрасывается исключение BufferUnderflowException.

В противном случае этот метод копирует length чисел с плавающей запятой из этого буфера в заданный массив, начиная с текущего положения этого буфера и заданного смещения в массиве. Положение этого буфера увеличивается на length.

Другими словами, вызов этого метода в форме src.get(dst, off, len) имеет точно такой же эффект, как цикл

for (int i = off; i < off + len; i++)
         dst[i] = src.get();
за исключением того, что он сначала проверяет, достаточно ли чисел с плавающей запятой в этом буфере, и потенциально намного эффективнее.
Параметры:
dst — массив, в который будут записаны числа с плавающей запятой
offset — смещение в массиве первого числа с плавающей запятой, которое будет записано; должно быть неотрицательным и не больше dst.length
length — максимальное количество чисел с плавающей запятой, которые будут записаны в заданный массив; должно быть неотрицательным и не больше dst.length - offset
Возвращает:
Этот буфер
Исключение:
BufferUnderflowException — если в этом буфере осталось меньше length чисел с плавающей запятой
IndexOutOfBoundsException — если условия для offset и length параметров не выполняются

get

public FloatBuffer get(float[] dst)

Относительный метод get для блоковой передачи.

Этот метод передает числа с плавающей запятой из этого буфера в заданный массив-приемник. Вызов этого метода в форме src.get(a) ведет себя точно так же, как вызов

src.get(a, 0, a.length)
Параметры:
dst — массив-приемник
Возвращает:
Этот буфер
Исключение:
BufferUnderflowException — если в этом буфере осталось меньше length чисел с плавающей запятой

put

public FloatBuffer put(FloatBuffer src)

Относительный метод put для блоковой передачи (необязательная операция).

Этот метод копирует оставшиеся числа с плавающей запятой из заданного буфера-источника в этот буфер. Если в буфере-источнике осталось больше чисел с плавающей запятой, чем в этом буфере, то есть, если src.remaining() > remaining(), то числа с плавающей запятой не передаются, и выбрасывается исключение BufferOverflowException.

В противном случае этот метод копирует n = src.remaining() чисел с плавающей запятой из заданного буфера в этот буфер, начиная с текущего положения каждого буфера. Положения обоих буферов увеличиваются на n.

Другими словами, вызов этого метода в форме dst.put(src) имеет точно такой же эффект, как цикл

while (src.hasRemaining())
         dst.put(src.get());
за исключением того, что он сначала проверяет наличие достаточного места в этом буфере и потенциально намного эффективнее.
Параметры:
src — буфер-источник, из которого будут считываться числа с плавающей запятой; не должен быть этим буфером
Возвращает:
Этот буфер
Исключение:
BufferOverflowException — если в этом буфере недостаточно места для оставшихся чисел с плавающей запятой в буфере-источнике
IllegalArgumentException — если буфер-источник — это этот буфер
ReadOnlyBufferException — если этот буфер только для чтения

put

public FloatBuffer put(float[] src,
                       int offset,
                       int length)

Метод put для массива с плавающей точкой ((необязательная операция)).

Этот метод копирует значения с плавающей точкой из заданного исходного массива в этот буфер. Если в массиве больше значений с плавающей точкой, чем места в этом буфере, то есть, если length > remaining(), то значения не копируются, и выбрасывается исключение BufferOverflowException.

В противном случае, этот метод копирует length значений с плавающей точкой из заданного массива в этот буфер, начиная с заданного смещения в массиве и текущей позиции в этом буфере. Позиция этого буфера затем увеличивается на length.

Другими словами, вызов этого метода в форме dst.put(src, off, len) имеет точно такой же эффект, как цикл 

for (int i = off; i < off + len; i++)
         dst.put(a[i]);
за исключением того, что он сначала проверяет наличие достаточного места в этом буфере и потенциально гораздо эффективнее.
Параметры:
src - Массив, из которого нужно считать значения с плавающей точкой
offset - Смещение в массиве первого значения с плавающей точкой для чтения; должно быть неотрицательным и не превышать array.length
length - Количество значений с плавающей точкой для чтения из заданного массива; должно быть неотрицательным и не превышать array.length - offset
Возвращает:
Этот буфер
Выбрасывает:
BufferOverflowException - Если в этом буфере недостаточно места
IndexOutOfBoundsException - Если условия предварительной проверки для параметров offset и length не соблюдены
ReadOnlyBufferException - Если этот буфер только для чтения

put

public final FloatBuffer put(float[] src)

Метод put для массива с плавающей точкой ((необязательная операция)).

Этот метод копирует все содержимое заданного исходного массива с плавающей точкой в этот буфер. Вызов этого метода в форме dst.put(a) ведет себя точно так же, как вызов 

dst.put(a, 0, a.length)
Параметры:
src - Исходный массив
Возвращает:
Этот буфер
Выбрасывает:
BufferOverflowException - Если в этом буфере недостаточно места
ReadOnlyBufferException - Если этот буфер только для чтения

hasArray

public final boolean hasArray()

Указывает, поддерживается ли этот буфер массивом с плавающей точкой, доступным для чтения/записи.

Если этот метод возвращает true, то методы array и arrayOffset могут быть безопасно вызваны.

Определено в:
hasArray в классе Buffer
Возвращает:
true если и только если этот буфер поддерживается массивом и не является только для чтения

array

public final float[] array()

Возвращает массив с плавающей точкой, который поддерживает этот буфер ((необязательная операция)).

Изменения в содержимом этого буфера приведут к изменению содержимого возвращаемого массива, и наоборот.

Вызовите метод hasArray перед вызовом этого метода, чтобы убедиться, что этот буфер имеет доступный массив поддержки.

Определено в:
array в классе Buffer
Возвращает:
Массив, поддерживающий этот буфер
Выбрасывает:
ReadOnlyBufferException - Если этот буфер поддерживается массивом, но является только для чтения
UnsupportedOperationException - Если этот буфер не поддерживается доступным массивом

arrayOffset

public final int arrayOffset()

Возвращает смещение в массиве поддержки этого буфера первого элемента буфера ((необязательная операция)).

Если этот буфер поддерживается массивом, то позиция буфера p соответствует индексу массива p + arrayOffset().

Вызовите метод hasArray перед вызовом этого метода, чтобы убедиться, что этот буфер имеет доступный массив поддержки.

Определено в:
arrayOffset в классе Buffer
Возвращает:
Смещение в массиве этого буфера первого элемента буфера
Выбрасывает:
ReadOnlyBufferException - Если этот буфер поддерживается массивом, но является только для чтения
UnsupportedOperationException - Если этот буфер не поддерживается доступным массивом

compact

public abstract FloatBuffer compact()

Компактует этот буфер ((необязательная операция)).

Значения с плавающей точкой между текущей позицией буфера и его пределом, если таковые имеются, копируются в начало буфера. То есть, значение с плавающей точкой с индексом p = position() копируется в индекс ноль, значение с плавающей точкой с индексом p + 1 копируется в индекс один, и так далее, пока значение с плавающей точкой с индексом limit() - 1 не будет скопировано в индекс n = limit() - 1 - p. Позиция буфера затем устанавливается в n+1, а его предел - в его ёмкость. Отметка, если она определена, отбрасывается.

Позиция буфера устанавливается в число скопированных значений с плавающей точкой, а не в ноль, чтобы вызов этого метода мог быть немедленно после вызова другого относительного метода put.

Возвращает:
Этот буфер
Выбрасывает:
ReadOnlyBufferException - Если этот буфер только для чтения

isDirect

public abstract boolean isDirect()

Указывает, является ли этот буфер с плавающей точкой прямым.

Определено в:
isDirect в классе Buffer
Возвращает:
true если и только если этот буфер прямой

toString

public String toString()

Возвращает строку, описывающую состояние этого буфера.

Переопределяет:
toString в классе Object
Возвращает:
Строка описания

hashCode

public int hashCode()

Возвращает текущий код хэширования этого буфера.

Код хэширования буфера с плавающей точкой зависит только от его оставшихся элементов; то есть от элементов с position() до и включая элемент в limit() - 1.

Поскольку коды хэширования буферов зависят от содержимого, не рекомендуется использовать буферы в качестве ключей в картах хэшей или подобных структурах данных, если неизвестно, что их содержимое не изменится.

Переопределяет:
hashCode в классе Object
Возвращает:
Текущий код хэширования этого буфера
См. также:
Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)

equals

public boolean equals(Object ob)

Определяет, равен ли этот буфер другому объекту.

Два буфера с плавающей точкой равны тогда и только тогда, когда:

  1. У них одинаковый тип элементов,

  2. У них одинаковое количество оставшихся элементов, и

  3. Две последовательности оставшихся элементов, рассматриваемые независимо от своих начальных позиций, равны попарно. Этот метод считает два элемента с плавающей точкой a и b равными, если (a == b) || (Float.isNaN(a) && Float.isNaN(b)). Значения -0.0 и +0.0 считаются равными, в отличие от Float.equals(Object).

Буфер с плавающей точкой не равен любому другому типу объекта.

Переопределяет:
equals в классе Object
Параметры:
ob - Объект, с которым нужно сравнить этот буфер
Возвращает:
true если и только если этот буфер равен заданному объекту
См. также:
Object.hashCode(), HashMap

compareTo

public int compareTo(FloatBuffer that)

Сравнивает этот буфер с другим.

Два буфера с плавающей точкой сравниваются путём лексикографического сравнения их последовательностей оставшихся элементов, не учитывая начальную позицию каждой последовательности в соответствующем буфере. Пары элементов с плавающей точкой float сравниваются так, как если бы вы вызывали Float.compare(float,float), за исключением того, что -0.0 и 0.0 считаются равными. Float.NaN в этом методе считается равным самому себе и больше всех других значений с плавающей точкой (включая Float.POSITIVE_INFINITY).

Буфер с плавающей точкой не сравним ни с каким другим типом объекта.

Определено в:
compareTo в интерфейсе Comparable<FloatBuffer>
Параметры:
that - сравниваемый объект.
Возвращает:
Отрицательное целое число, ноль или положительное целое число, если этот буфер меньше, равен или больше заданного буфера

mismatch

public int mismatch(FloatBuffer that)

Находит и возвращает относительный индекс первого несовпадения между этим буфером и заданным буфером. Индекс относит к position каждого буфера и будет в диапазоне от 0 (включительно) до меньшего из remaining элементов в каждом буфере (исключительно).

Если два буфера имеют общую префиксную часть, то возвращаемый индекс равен длине общей префиксной части, и из этого следует, что между двумя буферами есть несовпадение в этом индексе в пределах соответствующих буферов. Если один буфер является правильным префиксом другого, то возвращаемый индекс равен меньшему из оставшихся элементов в каждом буфере, и из этого следует, что индекс действителен только для буфера с большим количеством оставшихся элементов. В противном случае несовпадения нет.

Параметры:
that - Буфер с байтами, проверяемый на несовпадение с этим буфером
Возвращает:
Относительный индекс первого несовпадения между этим и заданным буфером, иначе -1, если несовпадения нет.
C момента:
11

order

public abstract ByteOrder order()

Возвращает порядок байтов этого буфера.

Порядок байтов буфера с плавающей точкой, созданного путём выделения памяти или путём обёртки существующего массива float, является native order базового оборудования. Порядок байтов буфера с плавающей точкой, созданного в виде представления буфера с байтами, соответствует порядку байтов буфера с байтами в момент создания представления.

Возвращает:
Порядок байтов этого буфера

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/FloatBuffer.html

Spec-Zone .ru
спецификации, руководства, описания, API