Класс LongBuffer

public static LongBuffer allocate(int capacity)

Выделяет новый буфер длинных целых чисел.

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

public static LongBuffer wrap(long[] array, int offset, int length)

Оборачивает массив длинных целых чисел в буфер.

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

public static LongBuffer wrap(long[] array)

Оборачивает массив длинных целых чисел в буфер.

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

public abstract LongBuffer slice()

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

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

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

public abstract LongBuffer slice(int index, int length)

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

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

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

public abstract LongBuffer duplicate()

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

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

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

public abstract LongBuffer asReadOnlyBuffer()

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

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

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

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

public abstract long get()

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

public abstract LongBuffer put(long l)

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

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

public abstract long get(int index)

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

public abstract LongBuffer put(int index, long l)

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

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

public LongBuffer get(long[] 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 LongBuffer get(long[] dst)

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

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

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

public LongBuffer get(int index, long[] dst, int offset, int length)

Метод получить абсолютного объёма.

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

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

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

public LongBuffer get(int index, long[] dst)

Метод получить абсолютного объёма.

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

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

public LongBuffer put(LongBuffer src)

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

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

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

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

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

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

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

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

Этот метод передает 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 LongBuffer put(long[] src, int offset, int length)

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

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

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

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

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

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

public final LongBuffer put(long[] src)

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

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

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

public LongBuffer put(int index, long[] src, int offset, int length)

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

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

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

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

public LongBuffer put(int index, long[] src)

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

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

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

public final boolean hasArray()

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

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

public final long[] array()

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

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

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

public final int arrayOffset()

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

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

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

public final LongBuffer position(int newPosition)

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

public final LongBuffer limit(int newLimit)

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

public final LongBuffer mark()

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

public final LongBuffer reset()

Возвращает позицию этого буфера к ранее помеченной позиции.

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

public final LongBuffer clear()

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

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

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

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

public final LongBuffer 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 LongBuffer rewind()

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

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

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

public abstract LongBuffer compact()

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

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

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

public abstract boolean isDirect()

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

public String toString()

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

public int hashCode()

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

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

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

public boolean equals(Object ob)

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

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

1. У них один и тот же тип элементов,

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

3. Две последовательности оставшихся элементов, рассматриваемые независимо от своих начальных позиций, точечно равны.

Буфер типа long не равен никакому другому типу объекта.

public int compareTo(LongBuffer that)

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

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

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

public int mismatch(LongBuffer that)

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

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

public abstract ByteOrder order()

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

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