Spec-Zone.ru › OpenJDK 27

Класс VectorShuffle<E>

java.lang.Object
jdk.incubator.vector.VectorShuffle<E>
Параметры типа:
E — упакованная версия ETYPE, типа элемента вектора
public abstract sealed class VectorShuffle<E> extends Object
VectorShuffle представляет собой упорядоченную неизменяемую последовательность значений int, называемых исходными индексами, где каждый исходный индекс численно выбирает исходную полосу совместимого Vector.

VectorShuffle и Vector одного и того же типа элементов (ETYPE) и shape имеют одинаковое число полос и поэтому совместимы (в частности, их vector species совместимы).

Перестановка применяется к совместимому исходному вектору с помощью метода rearrange.

Перестановка имеет структуру полос, заданную её видом вектора, но хранит индексы полос в виде int, а не значения полос.

Этот метод собирает значения полос, обращаясь к исходному вектору в произвольном порядке и выбирая полосы по исходным индексам. Если исходный индекс встречается в перестановке несколько раз, значение выбранной полосы копируется в результат несколько раз. Если исходный индекс не выбирает определённую полосу, её значение игнорируется. Результирующий вектор содержит все значения исходных полос, выбранные исходными индексами перестановки. Значения полос результирующего вектора упорядочены в соответствии с исходными индексами перестановки, а не с исходным порядком полос вектора.

Каждая перестановка имеет свойство vectorSpecies(), которое определяет совместимость векторов, с которыми работает перестановка. Это гарантирует, что length() перестановки всегда равна VLENGTH любого вектора, с которым она работает. Тип элемента и форма вида перестановки не имеют непосредственного отношения к её поведению. Перестановки можно легко преобразовать в другие типы полос, если количество полос остаётся неизменным.

Во внутреннем состоянии перестановка всегда хранит целочисленные значения в узком диапазоне от [-VLENGTH..VLENGTH-1]. Положительные числа говорят сами за себя: это номера полос, применяемые к любому исходному вектору. Отрицательные числа, если они есть, указывают на то, что перестановка была создана из необработанного целочисленного значения, которое не являлось допустимым индексом полосы.

Недопустимый исходный индекс, представленный в перестановке отрицательным числом, называется исключительным индексом.

Исключительные индексы обрабатываются различными способами:

  • Если не указано иное, методы, использующие перестановку, выбрасывают ArrayIndexOutOfBoundsException при обработке полосы с исключительным индексом.
  • Когда недопустимый исходный индекс (отрицательный или нет) впервые загружается в перестановку, он частично нормализуется в отрицательный диапазон [-VLENGTH..-1], как если бы применялась функция wrapIndex(). Такая обработка исключительных индексов называется частичным оборачиванием, поскольку она сохраняет различие между обычными и исключительными индексами, одновременно оборачивая их в соседние диапазоны положительных и неположительных чисел. Позже частично обёрнутый индекс можно полностью обернуть в положительный диапазон, добавив итоговое смещение VLENGTH.
  • В некоторых приложениях исключительные индексы используются для перенаправления доступа ко второму исходному вектору. В таких случаях значения исключительных индексов, находящиеся в диапазоне [-VLENGTH..-1], циклически переводятся в допустимый диапазон [0..VLENGTH-1] и применяются ко второму исходному вектору.
  • Когда перестановка преобразуется из другого вида перестановки с меньшим VLENGTH, все индексы повторно проверяются на соответствие новому VLENGTH, и некоторые из них могут быть преобразованы в исключительные индексы. В любом случае преобразование перестановки никогда не превращает исключительные индексы в обычные.

Классы, основанные на значениях, и операции идентификации

VectorShuffle вместе с Vector является классом, основанным на значениях. Операции, зависящие от идентичности, такие как ==, могут давать непредсказуемые результаты или снижать производительность. Кроме того, объекты перестановок векторов можно хранить в локальных переменных и параметрах, а также в виде констант static final, однако их хранение в других полях Java или элементах массива, хотя и семантически корректно, может привести к снижению производительности. Наконец, по возможности не следует вычислять перестановки векторов в циклах; вместо этого их следует хранить в инвариантных относительно цикла локальных переменных или в виде констант static final.

Краткое описание методов

Модификатор и тип Метод Описание
abstract <F> VectorShuffle<F> cast(VectorSpecies<F> species)
Преобразует эту перестановку в перестановку заданного вида с типом элемента F.
abstract <F> VectorShuffle<F> check(VectorSpecies<F> species)
Проверяет, что эта перестановка имеет заданный вид, и возвращает её без изменений.
abstract int checkIndex(int index)
Функция проверки индексов полос, которые могут выходить за допустимый диапазон [0..VLENGTH-1].
abstract VectorShuffle<E> checkIndexes()
Применяет функцию проверки checkIndex() ко всем полосам и выбрасывает IndexOutOfBoundsException, если в этой перестановке есть исключительные индексы.
final boolean equals(Object obj)
Указывает, идентична ли эта перестановка другому объекту.
static <E> VectorShuffle<E> fromArray(VectorSpecies<E> species, int[] sourceIndexes, int offset)
Создаёт перестановку заданного вида из массива int, начиная со смещения.
static final <E> VectorShuffle<E> fromMemorySegment(VectorSpecies<E> species, MemorySegment ms, long offset, ByteOrder bo)
Загружает перестановку из сегмента памяти, начиная со смещения в сегменте памяти.
static <E> VectorShuffle<E> fromOp(VectorSpecies<E> species, IntUnaryOperator fn)
Создаёт перестановку заданного вида из последовательных значений оператора, применённого к диапазону [0..VLENGTH-1].
static <E> VectorShuffle<E> fromValues(VectorSpecies<E> species, int... sourceIndexes)
Создаёт перестановку заданного вида из последовательности исходных индексов.
protected final Object getPayload()
final int hashCode()
Возвращает хеш-код перестановки, основанный на исходных индексах полос и виде вектора.
abstract void intoArray(int[] a, int offset)
Сохраняет эту перестановку в массив int, начиная со смещения.
abstract void intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo)
Сохраняет эту перестановку в сегмент памяти, начиная со смещения и используя явно заданный порядок байтов.
static <E> VectorShuffle<E> iota(VectorSpecies<E> species, int start, int step, boolean wrap)
Создаёт перестановку с исходными индексами, заданными последовательными значениями, начиная с start и увеличивающимися на заданное значение step.
abstract VectorMask<E> laneIsValid()
Находит все полосы с допустимыми индексами (неотрицательными значениями) и возвращает маску, в которой отмечены только эти полосы.
abstract int laneSource(int i)
Возвращает элемент типа int для полосы с индексом i
final int length()
Возвращает количество полос, обрабатываемых этой перестановкой.
static <E> VectorShuffle<E> makeUnzip(VectorSpecies<E> species, int part)
Создаёт перестановку, которая разделяет конкатенацию двух векторов, поочерёдно помещая входные полосы в один или другой выходной вектор.
static <E> VectorShuffle<E> makeZip(VectorSpecies<E> species, int part)
Создаёт перестановку, которая объединяет два вектора, поочерёдно выбирая полосы из одного или другого.
abstract VectorShuffle<E> rearrange(VectorShuffle<E> s)
Переставляет элементы полос этой перестановки, выбирая индексы полос согласно другой перестановке.
abstract int[] toArray()
Возвращает массив int, содержащий исходные индексы полос этой перестановки.
final String toString()
Возвращает строковое представление этой перестановки в форме "Shuffle[0,1,2...]", перечисляя исходные индексы в порядке полос.
abstract Vector<E> toVector()
Преобразует эту перестановку в вектор, создавая вектор целочисленных значений, соответствующих исходным индексам полос перестановки.
abstract VectorSpecies<E> vectorSpecies()
Возвращает вид этой перестановки.
abstract int wrapIndex(int index)
Функция проверки индексов полос, которые могут выходить за допустимый диапазон [0..VLENGTH-1].
abstract VectorShuffle<E> wrapIndexes()
Применяет функцию проверки wrapIndex() ко всем полосам, заменяя исключительные индексы обёрнутыми обычными индексами.

Методы, объявленные в классе Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait
Модификатор и тип Метод Описание
protected Object clone()
Создаёт и возвращает копию этого объекта.
protected void finalize()
Устарело и подлежит удалению: этот элемент API подлежит удалению в будущей версии.
Финализация устарела и подлежит удалению в одном из будущих выпусков.
final Class<?> getClass()
Возвращает класс времени выполнения этого Object.
final void notify()
Пробуждает один поток, ожидающий на мониторе этого объекта.
final void notifyAll()
Пробуждает все потоки, ожидающие на мониторе этого объекта.
final void wait()
Заставляет текущий поток ожидать пробуждения, обычно в результате вызова notify или interrupt.
final void wait(long timeoutMillis)
Заставляет текущий поток ожидать пробуждения, обычно в результате вызова notify или interrupt, либо до истечения заданного промежутка реального времени.
final void wait(long timeoutMillis, int nanos)
Заставляет текущий поток ожидать пробуждения, обычно в результате вызова notify или interrupt, либо до истечения заданного промежутка реального времени.

Подробное описание методов

vectorSpecies

public abstract VectorSpecies<E> vectorSpecies()
Возвращает вид этой перестановки.
Возвращает:
вид этой перестановки

length

public final int length()
Возвращает количество полос, обрабатываемых этой перестановкой. Оно совпадает с VLENGTH любого вектора, с которым она работает.
Возвращает:
количество полос перестановки

cast

public abstract <F> VectorShuffle<F> cast(VectorSpecies<F> species)
Преобразует эту перестановку в перестановку заданного вида с типом элемента F. Индексы источников различных полос остаются без изменений. Исключительные индексы источников остаются исключительными, а допустимые индексы остаются допустимыми.
Параметры типа:
F — упакованный тип элемента вида
Параметры:
species — вид требуемой перестановки
Возвращает:
перестановку, преобразованную по форме и типу элемента
Вызывает:
IllegalArgumentException — если длина этой перестановки и длина вида различаются

check

public abstract <F> VectorShuffle<F> check(VectorSpecies<F> species)
Проверяет, что эта перестановка имеет заданный вид, и возвращает эту перестановку без изменений. Эффект аналогичен следующему псевдокоду: species == vectorSpecies() ? this : throw new ClassCastException().
Параметры типа:
F — упакованный тип элемента требуемого вида
Параметры:
species — требуемый вид
Возвращает:
та же перестановка
Вызывает:
ClassCastException — если вид перестановки неверен
См. также:
  • Vector.check(Class)
  • Vector.check(VectorSpecies)

checkIndex

public abstract int checkIndex(int index)
Функция проверки индексов полос, которые могут находиться вне допустимого диапазона [0..VLENGTH-1]. Если index находится в этом диапазоне, он возвращается без изменений. В противном случае выбрасывается IndexOutOfBoundsException.
Параметры:
index — индекс полосы
Возвращает:
index
Вызывает:
IndexOutOfBoundsException — если index не меньше VLENGTH или является отрицательным
См. также:
  • wrapIndex(int)
  • checkIndexes()

wrapIndex

public abstract int wrapIndex(int index)
Функция проверки индексов полос, которые могут находиться вне допустимого диапазона [0..VLENGTH-1]. index приводится к этому диапазону путем прибавления или вычитания подходящего кратного VLENGTH. В частности, индекс приводится к требуемому диапазону путем вычисления значения length-floor, где floor=vectorSpecies().loopBound(length) — ближайшее меньшее кратное VLENGTH. Если VLENGTH является степенью двойки, то приведенный индекс также равен index & (VLENGTH - 1).
Параметры:
index — индекс полосы
Возвращает:
index, скорректированный до диапазона [0..VLENGTH-1} с помощью подходящего кратного VLENGTH
См. также:
  • VectorSpecies.loopBound(int)
  • checkIndex(int)
  • wrapIndexes()

checkIndexes

public abstract VectorShuffle<E> checkIndexes()
Применяет функцию проверки checkIndex() ко всем полосам, выбрасывая IndexOutOfBoundsException, если в этой перестановке есть исключительные индексы.
Возвращает:
текущую перестановку без изменений
Вызывает:
IndexOutOfBoundsException — если какие-либо полосы этой перестановки содержат исключительные индексы
См. также:
  • checkIndex(int)
  • wrapIndexes()

wrapIndexes

public abstract VectorShuffle<E> wrapIndexes()
Применяет функцию проверки wrapIndex() ко всем полосам, заменяя все исключительные индексы приведенными к диапазону обычными индексами.
Возвращает:
текущую перестановку, в которой все исключительные индексы приведены к диапазону
См. также:
  • wrapIndex(int)
  • checkIndexes()

laneIsValid

public abstract VectorMask<E> laneIsValid()
Находит все полосы, содержащие допустимые индексы (неотрицательные значения), и возвращает маску, в которой установлены только эти полосы.
Возвращает:
маску полос, содержащих допустимые индексы источников
См. также:
  • checkIndexes()

fromValues

public static <E> VectorShuffle<E> fromValues(VectorSpecies<E> species, int... sourceIndexes)
Создает перестановку для заданного вида на основе последовательности индексов источников.

Для каждой полосы перестановки, где N — индекс полосы перестановки, значение индекса под номером N проверяется относительно VLENGTH вида и (если оно недопустимо) частично приводится к исключительному индексу в диапазоне [-VLENGTH..-1].

Параметры типа:
E — упакованный тип элемента
Параметры:
species — вид перестановки
sourceIndexes — индексы источников, из которых будет выполняться выборка для перестановки
Возвращает:
перестановку, в которой индекс источника каждой полосы задан соответствующим значением int и частично приведен к диапазону, если он является исключительным
Вызывает:
IndexOutOfBoundsException — если sourceIndexes.length != VLENGTH
См. также:
  • VectorSpecies.shuffleFromValues(int...)

fromArray

public static <E> VectorShuffle<E> fromArray(VectorSpecies<E> species, int[] sourceIndexes, int offset)
Создает перестановку для заданного вида на основе массива int, начиная с указанного смещения.

Для каждой полосы перестановки, где N — индекс полосы перестановки, элемент массива с индексом offset + N проверяется относительно VLENGTH вида и (если он недопустим) частично приводится к исключительному индексу в диапазоне [-VLENGTH..-1].

Параметры типа:
E — упакованный тип элемента
Параметры:
species — вид перестановки
sourceIndexes — индексы источников, из которых будет выполняться выборка для перестановки
offset — смещение в массиве
Возвращает:
перестановку, в которой индекс источника каждой полосы задан соответствующим значением int и частично приведен к диапазону, если он является исключительным
Вызывает:
IndexOutOfBoundsException — если offset < 0 или offset > sourceIndexes.length - VLENGTH
См. также:
  • VectorSpecies.shuffleFromArray(int[], int)

fromMemorySegment

public static final <E> VectorShuffle<E> fromMemorySegment(VectorSpecies<E> species, MemorySegment ms, long offset, ByteOrder bo)
Загружает перестановку из сегмента памяти, начиная со смещения в сегменте памяти. Байты объединяются в полосы перестановки в соответствии с указанным порядком байтов. Полосы перестановки располагаются в соответствии с порядком в памяти.

Следующий псевдокод иллюстрирует поведение:

var slice = ms.asSlice(offset);
int[] ar = new int[species.length()];
for (int n = 0; n < ar.length; n++) {
    ar[n] = slice.getAtIndex(ValuaLayout.JAVA_INT_UNALIGNED, n);
}
VectorShuffle<E> r = VectorShuffle.fromArray(species, ar, 0);
Примечание по реализации:
Эта операция, вероятно, будет более эффективной, если указанный порядок байтов совпадает с собственным порядком байтов платформы, поскольку этому методу не потребуется менять порядок байтов значений полос.
Параметры типа:
E — упакованный тип элемента
Параметры:
species — вид перестановки
ms — индексы источников в памяти, из которых будет выполняться выборка для перестановки
offset — смещение в сегменте
bo — порядок байтов
Возвращает:
перестановку, в которой индекс источника каждой полосы задан соответствующим значением int и частично приведен к диапазону, если он является исключительным
Вызывает:
IndexOutOfBoundsException — если offset < 0 или offset > sourceIndexes.byteSize() - VLENGTH * 4
Начиная с версии:
25

fromOp

public static <E> VectorShuffle<E> fromOp(VectorSpecies<E> species, IntUnaryOperator fn)
Создает перестановку для заданного вида на основе последовательных значений оператора, примененного к диапазону [0..VLENGTH-1].

Для каждой полосы перестановки, где N — индекс полосы перестановки, значение индекса под номером N проверяется относительно VLENGTH вида и (если оно недопустимо) частично приводится к исключительному индексу в диапазоне [-VLENGTH..-1].

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

Этот метод действует так, как если бы перестановка создавалась на основе массива сопоставленных индексов следующим образом:

  int[] a = new int[species.length()];
  for (int i = 0; i < a.length; i++) {
      a[i] = fn.applyAsInt(i);
  }
  return VectorShuffle.fromArray(a, 0);
Параметры типа:
E — упакованный тип элемента
Параметры:
species — вид перестановки
fn — функция отображения индекса полосы
Возвращает:
перестановку сопоставленных индексов
См. также:
  • VectorSpecies.shuffleFromOp(IntUnaryOperator)

iota

public static <E> VectorShuffle<E> iota(VectorSpecies<E> species, int start, int step, boolean wrap)
Создает перестановку, используя индексы источников, заданные последовательными значениями, начиная с start и увеличивая их на указанное step.

Этот метод возвращает значение выражения VectorShuffle.fromOp(species, i -> R(start + i * step)), где R — это wrapIndex, если wrap имеет значение true, и тождественная функция в противном случае.

Если wrap имеет значение false, каждый индекс проверяется относительно VLENGTH вида и (если он недопустим) частично приводится к исключительному индексу в диапазоне [-VLENGTH..-1]. В противном случае, если wrap имеет значение true, каждый индекс также сокращается, как при использовании wrapIndex, до допустимого диапазона [0..VLENGTH-1].

Примечание к API:
Параметру wrap следует присвоить значение true, если недопустимые индексы источников нужно привести к диапазону. В противном случае значение false позволяет проверять диапазон недопустимых индексов источников при выполнении последующих операций, таких как unary rearrange.
Параметры типа:
E — упакованный тип элемента
Параметры:
species — вид перестановки
start — начальное значение последовательности индексов источников
step — разность между соседними индексами источников
wrap — следует ли приводить полученные индексы к диапазону
Возвращает:
перестановку последовательных индексов полос, возможно приведенных к диапазону
См. также:
  • VectorSpecies.iotaShuffle(int,int,boolean)

makeZip

public static <E> VectorShuffle<E> makeZip(VectorSpecies<E> species, int part)
Создает перестановку, которая объединяет два вектора, поочередно выбирая полосы из каждого из них. Логический результат объединения вдвое больше любого из входных векторов, поэтому расширенный результат разбивается на две физические части, выбираемые по номеру части. Например, объединение двух векторов [a,b,c,d] и [1,2,3,4] даст расширенный логический результат [a,1,b,2,c,3,d,4], который необходимо получить двумя частями: [a,1,b,2] и [c,3,d,4].

Этот метод возвращает значение выражения VectorShuffle.fromOp(species, i -> i/2 + (i%2)*VLENGTH + P, где P — part*VLENGTH/2.

s Обратите внимание, что индексы источников в нечетных полосах перестановки будут недопустимыми индексами (>= VLENGTH или < 0 после частичной нормализации), которые будут выбирать данные из второго вектора.

Параметры типа:
E — упакованный тип элемента
Параметры:
species — вид перестановки
part — номер части результата (ноль или один)
Возвращает:
перестановку, объединяющую два вектора в 2*VLENGTH полос, с возвратом выбранной части
Вызывает:
ArrayIndexOutOfBoundsException — если part не равен нулю или единице
См. также:
  • makeUnzip(VectorSpecies, int)
  • Vector.rearrange(VectorShuffle,Vector)

makeUnzip

public static <E> VectorShuffle<E> makeUnzip(VectorSpecies<E> species, int part)
Создает перестановку, которая разделяет конкатенацию двух векторов, поочередно помещая входные полосы в один или другой выходной вектор. Поскольку логический результат разделения вдвое больше любого из входных векторов, расширенный результат разбивается на две физические части, выбираемые по номеру части. Например, разделение двух векторов [a,1,b,2][c,3,d,4] даст результат из двух частей: [a,b,c,d] и [1,2,3,4].

Этот метод возвращает значение выражения VectorShuffle.fromOp(species, i -> i*2+part.

Обратите внимание, что индексы источников в верхней половине перестановки будут недопустимыми индексами (>= VLENGTH или < 0 после частичной нормализации), которые будут выбирать данные из второго вектора.

Параметры типа:
E — упакованный тип элемента
Параметры:
species — вид перестановки
part — номер части результата (ноль или один)
Возвращает:
перестановку, разделяющую 2*VLENGTH полос на два вектора, с возвратом выбранной части
Вызывает:
ArrayIndexOutOfBoundsException — если part не равен нулю или единице
См. также:
  • makeZip(VectorSpecies,int)
  • Vector.rearrange(VectorShuffle,Vector)

toArray

public abstract int[] toArray()
Возвращает массив int, содержащий индексы источников полос этой перестановки.

Этот метод действует так, как если бы он сохранял эту перестановку в выделенный массив (с использованием intoArray) и возвращал этот массив следующим образом:

  int[] a = new int[this.length()];
  VectorShuffle.intoArray(a, 0);
  return a;
Примечание к API:
Индексы источников перестановки всегда находятся в диапазоне от -VLENGTH до VLENGTH-1. Индекс источника является исключительным тогда и только тогда, когда он отрицательный.
Возвращает:
массив, содержащий индексы источников полос этой перестановки

intoArray

public abstract void intoArray(int[] a, int offset)
Сохраняет эту перестановку в массив int, начиная с заданного смещения.

Для каждой полосы перестановки N индекс источника полосы сохраняется в элемент массива a[offset+N].

Примечание к API:
Индексы источников перестановки всегда находятся в диапазоне от -VLENGTH до VLENGTH-1.
Параметры:
a — массив типа int[]
offset — смещение в массиве
Вызывает:
IndexOutOfBoundsException — если offset < 0 или offset > a.length - this.length()

intoMemorySegment

public abstract void intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo)
Сохраняет эту перестановку в сегмент памяти, начиная со смещения и используя явный порядок байтов.

Байты извлекаются из полос перестановки в соответствии с указанным порядком байтов. Полосы перестановки сохраняются в соответствии с их порядком в памяти.

Следующий псевдокод иллюстрирует поведение:

int[] a = this.toArray();
var slice = ms.asSlice(offset)
for (int n = 0; n < a.length; n++) {
    slice.setAtIndex(ValueLayout.JAVA_INT_UNALIGNED, n, a[n]);
}
Примечание к API:
Индексы источников перестановки всегда находятся в диапазоне от -VLENGTH до VLENGTH-1.
Примечание по реализации:
Эта операция, вероятно, будет более эффективной, если указанный порядок байтов совпадает с собственным порядком байтов платформы, поскольку этому методу не потребуется менять порядок байтов значений полос.
Параметры:
ms — сегмент памяти
offset — смещение в сегменте
bo — порядок байтов
Вызывает:
IndexOutOfBoundsException — если offset < 0 или offset > a.byteSize() - this.length() * 4
IllegalArgumentException — если сегмент ms доступен только для чтения
Начиная с версии:
25

toVector

public abstract Vector<E> toVector()
Преобразует эту перестановку в вектор, создавая вектор целочисленных значений, соответствующих индексам источников полос перестановки.

Этот метод действует так, как если бы он возвращал результат создания вектора на основе массива int, полученного из элементов полос этой перестановки, следующим образом:

  int[] sa = this.toArray();
  $type$[] va = new $type$[a.length];
  for (int i = 0; i < a.length; i++) {
      va[i] = ($type$) sa[i];
  }
  return IntVector.fromArray(va, 0);
Примечание к API:
Индексы источников перестановки всегда находятся в диапазоне от -VLENGTH до VLENGTH-1. Эти значения преобразуются в ETYPE результирующего вектора, даже если он имеет тип с плавающей точкой.
Возвращает:
представление этой перестановки в виде вектора

laneSource

public abstract int laneSource(int i)
Получает элемент полосы типа int с индексом полосы i
Параметры:
i — индекс полосы
Возвращает:
элемент полосы типа int с индексом полосы i

rearrange

public abstract VectorShuffle<E> rearrange(VectorShuffle<E> s)
Изменяет порядок элементов полос этой перестановки, выбирая индексы полос, задаваемые другой перестановкой.

Для каждой полосы указанной перестановки с индексом полосы N и элементом полосы I выбирается элемент полосы с индексом I из этой перестановки и помещается в результирующую перестановку по индексу N.

Параметры:
s — перестановка, задающая выбор индексов полос
Возвращает:
перестановку элементов полос этой перестановки

toString

public final String toString()
Возвращает строковое представление этой перестановки в форме "Shuffle[0,1,2...]", отображающее индексы источников в порядке полос.
Переопределяет:
toString в классе Object
Возвращает:
строку в форме "Shuffle[0,1,2...]"

equals

public final boolean equals(Object obj)
Указывает, идентична ли эта перестановка другому объекту. Две перестановки идентичны, только если у них одинаковые виды и одинаковые индексы источников в одном и том же порядке.
Переопределяет:
equals в классе Object
Параметры:
obj — объект-ссылка, с которым выполняется сравнение.
Возвращает:
указывает, идентичен ли этот вектор другому объекту
См. также:
  • Object.hashCode()
  • HashMap

hashCode

public final int hashCode()
Возвращает хеш-код перестановки, основанный на индексах источников полос и виде вектора.
Переопределяет:
hashCode в классе Object
Возвращает:
хеш-код этой перестановки
См. также:
  • Object.equals(java.lang.Object)
  • System.identityHashCode(Object)

getPayload

protected final Object getPayload()

Сообщить об ошибке или предложить улучшение
Дополнительные справочные материалы по API и документацию для разработчиков см. в документации Java SE, содержащей более подробные описания для разработчиков, концептуальные обзоры, определения терминов, обходные решения и примеры работающего кода. Другие версии.
Java является товарным знаком или зарегистрированным товарным знаком Oracle и/или ее дочерних компаний в США и других странах.
Авторское право © 1993, 2026, Oracle и/или ее дочерние компании, 500 Oracle Parkway, Redwood Shores, CA 94065 USA.
Все права защищены. Использование регулируется условиями лицензии и политикой распространения документации.

© 1993, 2025, 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.

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API