Класс ByteBuffer

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Этот метод переносит 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));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

После последовательности операций чтения канала или 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 при передаче данных из одного места в другое.

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

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

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

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

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

    buf.clear();          // Prepare buffer for use
    while (in.read(buf) >= 0 || buf.position != 0) {
        buf.flip();
        out.write(buf);
        buf.compact();    // In case of partial write
    }

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

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

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

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

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

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

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

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

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

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

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

Возвращаемое значение неотрицательно в диапазоне от 0 (включительно) до unitSize (исключительно), при этом ноль указывает, что адрес байта по индексу выровнен по размеру блока, а положительное значение — что адрес не выровнен. Если адрес байта по индексу не выровнен, возвращаемое значение представляет собой величину, на которую необходимо скорректировать индекс, чтобы найти байт с выровненным адресом. Конкретно, индекс должен быть уменьшен на возвращаемое значение, если последнее не больше index, или увеличен на размер блока минус возвращаемое значение. Следовательно, при

    int value = alignmentOffset(index, unitSize)

    alignmentOffset(index - value, unitSize) == 0, value <= index

    alignmentOffset(index + (unitSize - value), unitSize) == 0

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

    nb.alignmentOffset(0, unitSize) == 0
    nb.alignmentOffset(nb.limit(), unitSize) == 0

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

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

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

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

Читает два байта по указанному индексу, формируя из них значение типа char в соответствии с текущим порядком байтов.

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

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

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

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

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

Читает два байта по указанному индексу, формируя из них значение типа short в соответствии с текущим порядком байтов.

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

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

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

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

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

Читает четыре байта по указанному индексу, формируя из них значение типа int в соответствии с текущим порядком байтов.

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

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

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

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

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

Читает восемь байтов по заданному индексу, объединяя их в значение типа long в соответствии с текущим порядком байтов.

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

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

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

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

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

Читает четыре байта по заданному индексу, объединяет их в значение типа float в соответствии с текущим порядком байтов.

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

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

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

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

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

Читает восемь байтов по заданному индексу, объединяет их в значение типа double в соответствии с текущим порядком байтов.

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

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

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