Класс IntBuffer

public static IntBuffer allocate(int capacity)

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

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

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

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

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

public static IntBuffer wrap(int[] array)

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

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

public abstract IntBuffer slice()

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

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

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

public abstract IntBuffer slice(int index, int length)

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

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

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

public abstract IntBuffer duplicate()

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

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

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

public abstract IntBuffer asReadOnlyBuffer()

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

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

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

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

public abstract int get()

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

public abstract IntBuffer put(int i)

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

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

public abstract int get(int index)

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

public abstract IntBuffer put(int index, int i)

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

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

public IntBuffer get(int[] dst, int offset, int length)

Метод массового считывания относительно.

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

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

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

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

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

public IntBuffer get(int[] dst)

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

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

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

public IntBuffer get(int index, int[] 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 IntBuffer get(int index, int[] dst)

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

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

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

public IntBuffer put(IntBuffer src)

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

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

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

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

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

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

public IntBuffer put(int index, IntBuffer 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 IntBuffer put(int[] 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 IntBuffer put(int[] src)

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

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

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

public IntBuffer put(int index, int[] 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 IntBuffer put(int index, int[] src)

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

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

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

public final boolean hasArray()

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

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

public final int[] array()

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

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

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

public final int arrayOffset()

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

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

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

public final IntBuffer position(int newPosition)

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

public final IntBuffer limit(int newLimit)

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

public final IntBuffer mark()

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

public final IntBuffer reset()

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

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

public final IntBuffer clear()

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

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

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

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

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

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

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

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

public abstract IntBuffer compact()

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

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

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

public abstract boolean isDirect()

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

public String toString()

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

public int hashCode()

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

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

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

public boolean equals(Object ob)

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

Два целочисленных буфера равны тогда и только тогда, когда

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

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

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

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

public int compareTo(IntBuffer that)

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

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

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

public int mismatch(IntBuffer that)

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

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

public abstract ByteOrder order()

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

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