Класс LongBuffer

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

Буфер для хранения значений типа long.

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

  • Абсолютные и относительные методы get и put для чтения и записи отдельных значений типа long;

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

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

  • Метод для compacting буфера long.

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

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

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

С тех пор:
1.4

Методы

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

Выделяет новый буфер long.
long[] array()

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

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

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

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

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

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

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

Относительный метод get.
abstract long get​(int index)

Абсолютный метод get.
LongBuffer get​(long[] dst)

Относительный метод get для блоков данных.
LongBuffer get​(long[] dst, int offset, int length)

Относительный метод get для блоков данных.
boolean hasArray()

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

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

Определяет, является ли этот буфер long прямым.
int mismatch​(LongBuffer that)

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

Получает порядок байтов этого буфера.
abstract LongBuffer put​(int index, long l)

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

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

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

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

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

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

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

Оборачивает массив long в буфер.
static LongBuffer wrap​(long[] array, int offset, int length)

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

Методы, унаследованные от класса 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 LongBuffer allocate(int capacity)

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

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

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

wrap

public static LongBuffer wrap(long[] 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 LongBuffer wrap(long[] array)

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

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

Параметры:
array - Массив, который будет поддерживать этот буфер
Возвращает:
Новый буфер длинных целых

slice

public abstract LongBuffer slice()

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

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

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

Определено в:
slice в классе Buffer
Возвращает:
Новый буфер длинных целых

duplicate

public abstract LongBuffer duplicate()

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

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

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

Определено в:
duplicate в классе Buffer
Возвращает:
Новый буфер длинных целых

asReadOnlyBuffer

public abstract LongBuffer asReadOnlyBuffer()

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

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

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

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

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

get

public abstract long get()

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

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

put

public abstract LongBuffer put(long l)

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

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

Параметры:
l - Длинное целое, которое нужно записать
Возвращает:
Этот буфер
Исключения:
BufferOverflowException - Если текущая позиция этого буфера не меньше его предела
ReadOnlyBufferException - Если этот буфер только для чтения

get

public abstract long get(int index)

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

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

put

public abstract LongBuffer put(int index,
                               long l)

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

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

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

get

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();
за исключением того, что он сначала проверяет наличие достаточного количества длинных целых в этом буфере и потенциально намного эффективнее.
Параметры:
dst - Массив, в который будут записаны длинные целые
offset - Смещение в массиве первого длинного целого, которое должно быть записано; должно быть неотрицательным и не больше dst.length
length - Максимальное количество длинных целых, которые должны быть записаны в заданный массив; должно быть неотрицательным и не больше dst.length - offset
Возвращает:
Этот буфер
Исключения:
BufferUnderflowException - Если в этом буфере меньше, чем length длинных целых
IndexOutOfBoundsException - Если условия для offset и length параметров не выполняются

get

public LongBuffer get(long[] dst)

Относительный метод get для нескольких элементов.

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

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

put

public LongBuffer put(LongBuffer 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 LongBuffer put(long[] src,
                      int offset,
                      int length)

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

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

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

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

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

put

public final LongBuffer put(long[] src)

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

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

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

hasArray

public final boolean hasArray()

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

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

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

array

public final long[] array()

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

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

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

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

arrayOffset

public final int arrayOffset()

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

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

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

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

compact

public abstract LongBuffer compact()

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

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

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

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

isDirect

public abstract boolean isDirect()

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

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

toString

public String toString()

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

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

hashCode

public int hashCode()

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

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

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

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

equals

public boolean equals(Object ob)

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

Два буфера long равны тогда и только тогда, когда

  1. Они имеют тот же тип элементов,

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

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

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

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

compareTo

public int compareTo(LongBuffer that)

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

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

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

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

mismatch

public int mismatch(LongBuffer that)

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

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

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

order

public abstract ByteOrder order()

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

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

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

© 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/LongBuffer.html

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