Класс FloatBuffer

public static FloatBuffer allocate(int capacity)

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

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

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

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

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

public static FloatBuffer wrap(float[] array)

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

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

public abstract FloatBuffer slice()

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

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

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

public abstract FloatBuffer slice(int index, int length)

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

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

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

public abstract FloatBuffer duplicate()

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

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

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

public abstract FloatBuffer asReadOnlyBuffer()

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

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

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

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

public abstract float get()

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

public abstract FloatBuffer put(float f)

Метод относительного put (дополнительная операция).

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

public abstract float get(int index)

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

public abstract FloatBuffer put(int index, float f)

Метод абсолютного put (дополнительная операция).

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

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();
 

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

public FloatBuffer get(float[] dst)

Метод get относительного объёма.

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

     src.get(a, 0, a.length) 

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

Метод get абсолютного объёма.

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

Вызов этого метода в форме src.get(index, dst, offset, length) имеет точно такой же эффект, как следующий цикл, за исключением того, что он сначала проверяет согласованность переданных параметров и потенциально является гораздо более эффективным:

     for (int i = offset, j = index; i < offset + length; i++, j++)
         dst[i] = src.get(j);
 

public FloatBuffer get(int index, float[] dst)

Метод get абсолютного объёма.

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

     src.get(index, dst, 0, dst.length) 

public FloatBuffer put(FloatBuffer src)

Метод put относительного объёма (необязательная операция).

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

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

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

     while (src.hasRemaining())
         dst.put(src.get()); 

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

public FloatBuffer put(int index, FloatBuffer src, int offset, int length)

Метод put абсолютного объёма (необязательная операция).

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

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

 for (int i = offset, j = index; i < offset + length; i++, j++)
     dst.put(j, src.get(i));
 

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

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(src[i]);
 

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

public final FloatBuffer put(float[] src)

Метод put относительного объёма (необязательная операция).

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

     dst.put(a, 0, a.length) 

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

Метод put абсолютного объёма (необязательная операция).

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

Вызов этого метода в форме dst.put(index, src, offset, length) имеет точно такой же эффект, как следующий цикл, за исключением того, что он сначала проверяет согласованность переданных параметров и потенциально является гораздо более эффективным:

     for (int i = offset, j = index; i < offset + length; i++, j++)
         dst.put(j, src[i]);
 

public FloatBuffer put(int index, float[] src)

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

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

     dst.put(index, src, 0, src.length); 

public final boolean hasArray()

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

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

public final float[] array()

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

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

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

public final int arrayOffset()

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

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

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

public final FloatBuffer position(int newPosition)

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

public final FloatBuffer limit(int newLimit)

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

public final FloatBuffer mark()

Устанавливает метку этого буфера в его позиции.

public final FloatBuffer reset()

Сбрасывает позицию этого буфера до ранее помеченной позиции.

Вызов этого метода не изменяет и не отбрасывает значение метки.

public final FloatBuffer clear()

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

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

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

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

public final FloatBuffer flip()

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

После последовательности операций чтения или записи канала вызовите этот метод, чтобы подготовиться к последовательности операций записи канала или относительных операций get. Например:

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

Этот метод часто используется совместно с методом compact при передаче данных из одного места в другое.

public final FloatBuffer rewind()

Перематывает этот буфер. Позиция устанавливается в ноль, и метка отбрасывается.

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

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

public abstract FloatBuffer compact()

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

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

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

public abstract boolean isDirect()

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

public String toString()

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

public int hashCode()

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

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

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

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).

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

public int compareTo(FloatBuffer that)

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

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

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

public int mismatch(FloatBuffer that)

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

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

public abstract ByteOrder order()

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

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