Spec-Zone.ru › OpenJDK 25

Класс VectorShuffle<E>

java.lang.Object
jdk.incubator.vector.VectorShuffle<E>
Параметры типа:
E — упакованная версия ETYPE, тип элемента вектора
public abstract 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

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

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)
Создает перемешивание, объединяющее два вектора с чередованием полос, выбранных из каждого из них. Логический результат zip-операции вдвое больше любого входного вектора, поэтому расширенный результат разбивается на две физические части, выбираемые по номеру части. Например, объединение двух векторов [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)
Создает перемешивание, разделяющее объединение двух векторов и поочередно помещающее входные полосы в один или другой выходной вектор. Поскольку логический результат unzip-операции вдвое больше любого входного вектора, расширенный результат разбивается на две физические части, выбираемые по номеру части. Например, разделение двух векторов [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, 2025, 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.
https://docs.oracle.com/en/java/javase/25/docs/api/jdk.incubator.vector/jdk/incubator/vector/VectorShuffle.html

Spec-Zone.ru

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