Класс DoubleBuffer

public static DoubleBuffer allocate(int capacity)

Выделяет новый буфер для double.

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

public static DoubleBuffer wrap(double[] array, int offset, int length)

Оборачивает массив double в буфер.

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

public static DoubleBuffer wrap(double[] array)

Оборачивает массив double в буфер.

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

public abstract DoubleBuffer slice()

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

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

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

public abstract DoubleBuffer slice(int index, int length)

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

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

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

public abstract DoubleBuffer duplicate()

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

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

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

public abstract DoubleBuffer asReadOnlyBuffer()

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

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

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

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

public abstract double get()

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

public abstract DoubleBuffer put(double d)

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

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

public abstract double get(int index)

Абсолютный метод get. Читает double по заданному индексу.

public abstract DoubleBuffer put(int index, double d)

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

Записывает данное double в этот буфер по заданному индексу.

public DoubleBuffer get(double[] dst, int offset, int length)

Относительный метод массового get.

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

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

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

     for (int i = off; i < off + len; i++)
         dst[i] = src.get();
 

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

public DoubleBuffer get(double[] dst)

Метод относительного копирования массива get.

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

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

public DoubleBuffer get(int index, double[] dst, int offset, int length)

Метод абсолютного копирования массива get.

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

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

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

public DoubleBuffer get(int index, double[] dst)

Метод абсолютного копирования массива get.

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

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

public DoubleBuffer put(DoubleBuffer src)

Метод относительного копирования буфера put (необязательная операция).

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

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

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

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

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

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

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

Этот метод копирует length значений типа double в этот буфер из заданного исходного буфера, начиная с заданного 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 DoubleBuffer put(double[] src, int offset, int length)

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

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

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

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

     for (int i = off; i < off + len; i++)
         dst.put(src[i]);
 

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

public final DoubleBuffer put(double[] src)

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

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

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

public DoubleBuffer put(int index, double[] src, int offset, int length)

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

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

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

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

public DoubleBuffer put(int index, double[] src)

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

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

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

public final boolean hasArray()

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

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

public final double[] array()

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

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

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

public final int arrayOffset()

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

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

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

public final DoubleBuffer position(int newPosition)

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

public final DoubleBuffer limit(int newLimit)

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

public final DoubleBuffer mark()

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

public final DoubleBuffer reset()

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

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

public final DoubleBuffer clear()

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

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

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

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

public final DoubleBuffer flip()

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

После последовательности операций чтения канала или операций put вызовите этот метод, чтобы подготовиться к последовательности операций записи в канал или относительных операций 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 DoubleBuffer rewind()

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

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

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

public abstract DoubleBuffer compact()

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

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

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

public abstract boolean isDirect()

Указывает, является ли этот буфер double-буфером прямого доступа.

public String toString()

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

public int hashCode()

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

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

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

public boolean equals(Object ob)

Указывает, равен ли этот буфер другому объекту.

Два double-буфера равны, если и только если:

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

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

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

Double-буфер не равен любому другому типу объекта.

public int compareTo(DoubleBuffer that)

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

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

Буфер double не может быть сравнен ни с каким другим типом объекта.

public int mismatch(DoubleBuffer that)

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

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

public abstract ByteOrder order()

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

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