Module jdk.incubator.vector
Package jdk.incubator.vector

Class IntVector

java.lang.Object
jdk.incubator.vector.Vector<Integer>
jdk.incubator.vector.IntVector
public abstract class IntVector extends Vector<Integer>
IntVector 依赖于Java平台的预览功能：
仅当启用预览功能时，程序才能使用 IntVector。
预览功能可能会在未来的版本中被移除，或升级为Java平台的永久功能。
代表有序不可变的 Vector，其中包含 int 值序列。

  • Field Details

  • Method Details

    • zero

      public static IntVector zero(VectorSpecies<Integer> species)
      Returns a vector of the given species where all lane elements are set to zero, the default primitive value.
      参数：
      species - 所需零向量的种类
      返回：
      一个零向量

    • broadcast

      public abstract IntVector broadcast(int e)
      返回与此向量相同种类的向量，其中所有通道元素均设置为原始值e。当前向量的内容将被丢弃；此操作只与种类相关。

      此方法返回此表达式的值：IntVector.broadcast(this.species(), e)。

      API注释：
      与超类型Vector中名为broadcast()的类似方法不同，此方法不需要验证其参数，并且不会抛出IllegalArgumentException。因此，此方法优于超类型方法。
      参数：
      e - 要广播的值
      返回：
      所有通道元素均设置为原始值e的向量
      参见：

    • broadcast

      public static IntVector broadcast(VectorSpecies<Integer> species, int e)
      返回与给定种类相同的向量，其中所有通道元素均设置为原始值e。
      参数：
      species - 所需向量的种类
      e - 要广播的值
      返回：
      所有通道元素均设置为原始值e的向量
      参见：

    • broadcast

      public abstract IntVector broadcast(long e)
      返回一个与当前向量相同类型的向量，其中所有的lane元素都设置为原始值e。当前向量的内容将被丢弃；只有类型对这个操作是相关的。

      该方法返回这个表达式的值：EVector.broadcast(this.species(), (ETYPE)e)，其中EVector是特定于该向量元素类型ETYPE的向量类。

      必须准确地表示long值e，以便e==(long)(ETYPE)e。如果违反了这个规则，问题不会在静态时被检测到，但会在运行时抛出IllegalArgumentException。因此，这个方法在一定程度上削弱了对立即常量和其他标量的静态类型检查，但通过提高通用API的表达能力来弥补这一点。请注意，范围在[-128..127]的e值总是可接受的，因为每个ETYPE都将接受每个byte值。

      指定者：
      broadcast 在类 Vector<Integer>
      API注释：
      当使用像IntVector这样的向量子类型时，通常会选择更强类型的方法。可以使用强制转换来明确选择：v.broadcast((int)e)。这两个表达式将产生数值上相同的结果。
      参数：
      e - 要广播的值
      返回：
      一个向量，其中所有的lane元素都设置为原始值e
      参见：

    • broadcast

      public static IntVector broadcast(VectorSpecies<Integer> species, long e)
      返回一个给定类型的向量，其中所有的lane元素都设置为原始值e。必须准确表示long值，以便e==(long)(ETYPE)e。
      参数：
      species - 所需向量的类型
      e - 要广播的值
      返回：
      一个向量，其中所有的lane元素都设置为原始值e
      抛出：
      IllegalArgumentException - 如果给定的long值不能被向量的ETYPE表示
      参见：

    • lanewise

      public abstract IntVector lanewise(VectorOperators.Unary op)
      操作这个向量的lane值。这是一个逐lane一元操作，将所选操作应用于每个lane。
      指定者：
      lanewise 在类 Vector<Integer>
      参数：
      op - 用于处理lane值的操作
      返回：
      将操作逐lane应用于输入向量的结果
      参见：

    • lanewise

      public abstract IntVector lanewise(VectorOperators.Unary op, VectorMask<Integer> m)
      操作这个向量的lane值，通过掩码控制lane元素的选择。这是一个逐lane一元操作，将所选操作应用于每个lane。
      指定者：
      lanewise 在类 Vector<Integer>
      参数：
      op - 用于处理lane值的操作
      m - 控制lane选择的掩码
      返回：
      将操作逐lane应用于输入向量的结果
      参见：

    • lanewise

      public abstract IntVector lanewise(VectorOperators.Binary op, Vector<Integer> v)
      将这个向量的对应lane值与第二个输入向量的对应lane值组合。这是一个逐lane二元操作，将所选操作应用于每个lane。
      指定者：
      lanewise 在类 Vector<Integer>
      参数：
      op - 用于组合lane值的操作
      v - 输入向量
      返回：
      将操作逐lane应用于两个输入向量的结果
      参见：

    • lanewise

      public abstract IntVector lanewise(VectorOperators.Binary op, Vector<Integer> v, VectorMask<Integer> m)
      将这个向量的对应lane值与第二个输入向量的对应lane值组合，通过掩码控制lane元素的选择。这是一个逐lane二元操作，将所选操作应用于每个lane。
      指定者：
      lanewise 在类 Vector<Integer>
      参数：
      op - 用于组合lane值的操作
      v - 第二个输入向量
      m - 控制lane选择的掩码
      返回：
      将操作逐lane应用于两个输入向量的结果
      参见：

    • lanewise

      public final IntVector lanewise(VectorOperators.Binary op, int e)
      将这个向量的lane值与广播标量的值组合。这是一个逐lane二元操作，将所选操作应用于每个lane。返回值将等于这个表达式：this.lanewise(op, this.broadcast(e))。
      参数：
      op - 用于处理lane值的操作
      e - 输入标量
      返回：
      将操作逐lane应用于两个输入向量的结果
      抛出：
      UnsupportedOperationException - 如果这个向量不支持请求的操作
      参见：

    • lanewise

      public final IntVector lanewise(VectorOperators.Binary op, int e, VectorMask<Integer> m)
      将这个向量的lane值与广播标量的值组合，通过掩码控制lane元素的选择。这是一个掩码逐lane二元操作，将所选操作应用于每个lane。返回值将等于这个表达式：this.lanewise(op, this.broadcast(e), m)。
      参数：
      op - 用于处理lane值的操作
      e - 输入标量
      m - 控制lane选择的掩码
      返回：
      将操作逐lane应用于输入向量和标量的结果
      抛出：
      UnsupportedOperationException - 如果这个向量不支持请求的操作
      参见：

    • lanewise

      public final IntVector lanewise(VectorOperators.Binary op, long e)
      将这个向量的lane值与广播标量的值组合。这是一个逐lane二元操作，将所选操作应用于每个lane。返回值将等于这个表达式：this.lanewise(op, this.broadcast(e))。
      指定者：
      lanewise 在类 Vector<Integer>中
      API注释：
      当使用向量子类型如IntVector时，通常会选择更强类型的方法。可以使用强制转换来显式选择： v.lanewise(op,(int)e)。这两个表达式将产生数值上相同的结果。
      参数：
      op - 用于组合通道值的操作
      e - 输入标量
      返回：
      将操作逐通道应用于输入向量和标量的结果
      参见：

    • lanewise

      public final IntVector lanewise(VectorOperators.Binary op, long e, VectorMask<Integer> m)
      将此向量的相应通道值与第二个输入向量的通道值组合，通过掩码控制通道元素的选择。这是一种逐通道二元操作，将所选操作应用于每个通道。第二个操作数是广播整数值。返回值将等于此表达式：this.lanewise(op, this.broadcast(e), m)。
      指定者：
      lanewise 在类 Vector<Integer>中
      API注释：
      当使用向量子类型如IntVector时，通常会选择更强类型的方法。可以使用强制转换来显式选择： v.lanewise(op,(int)e,m)。这两个表达式将产生数值上相同的结果。
      参数：
      op - 用于组合通道值的操作
      e - 输入标量
      m - 控制通道选择的掩码
      返回：
      将操作逐通道应用于输入向量和标量的结果
      参见：

    • lanewise

      public abstract IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2)
      将此向量的相应通道值与第二个和第三个输入向量的通道值组合。这是一种逐通道三元操作，将所选操作应用于每个通道。
      指定者：
      lanewise 在类 Vector<Integer>中
      参数：
      op - 用于组合通道值的操作
      v1 - 第二个输入向量
      v2 - 第三个输入向量
      返回：
      将操作逐通道应用于三个输入向量的结果
      参见：

    • lanewise

      public abstract IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> m)
      将此向量的相应通道值与第二个和第三个输入向量的通道值组合，通过掩码控制通道元素的选择。这是一种逐通道三元操作，将所选操作应用于每个通道。
      指定者：
      lanewise 在类 Vector<Integer>中
      参数：
      op - 用于组合通道值的操作
      v1 - 第二个输入向量
      v2 - 第三个输入向量
      m - 控制通道选择的掩码
      返回：
      将操作逐通道应用于三个输入向量的结果
      参见：

    • lanewise

      public final IntVector lanewise(VectorOperators.Ternary op, int e1, int e2)
      将此向量的通道值与两个广播标量的值组合。这是一种逐通道三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, this.broadcast(e1), this.broadcast(e2))。
      参数：
      op - 用于组合通道值的操作
      e1 - 第一个输入标量
      e2 - 第二个输入标量
      返回：
      将操作逐通道应用于输入向量和标量的结果
      抛出：
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见：

    • lanewise

      public final IntVector lanewise(VectorOperators.Ternary op, int e1, int e2, VectorMask<Integer> m)
      将此向量的通道值与两个广播标量的值组合，通过掩码控制通道元素的选择。这是一种带掩码的逐通道三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, this.broadcast(e1), this.broadcast(e2), m)。
      参数：
      op - 用于组合通道值的操作
      e1 - 第一个输入标量
      e2 - 第二个输入标量
      m - 控制通道选择的掩码
      返回：
      将操作逐通道应用于输入向量和标量的结果
      抛出：
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见：

    • lanewise

      public final IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2)
      将此向量的通道值与另一个向量和一个广播标量的值组合。这是一种逐通道三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, v1, this.broadcast(e2))。
      参数：
      op - 用于组合通道值的操作
      v1 - 另一个输入向量
      e2 - 输入标量
      返回：
      将操作逐通道应用于输入向量和标量的结果
      抛出：
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见：

    • lanewise

      public final IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2, VectorMask<Integer> m)
      将此向量的通道值与另一个向量和广播标量的值结合，通过掩码控制通道元素的选择。这是一种掩码通道级三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, v1, this.broadcast(e2), m)。
      参数:
      op - 用于结合通道值的操作
      v1 - 另一个输入向量
      e2 - 输入标量
      m - 控制通道选择的掩码
      返回:
      将操作应用于输入向量和标量的结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • lanewise

      public final IntVector lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2)
      将此向量的通道值与另一个向量和广播标量的值结合。这是一种通道级三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, this.broadcast(e1), v2)。
      参数:
      op - 用于结合通道值的操作
      e1 - 输入标量
      v2 - 另一个输入向量
      返回:
      将操作应用于输入向量和标量的结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • lanewise

      public final IntVector lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2, VectorMask<Integer> m)
      将此向量的通道值与另一个向量和广播标量的值结合，通过掩码控制通道元素的选择。这是一种掩码通道级三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, this.broadcast(e1), v2, m)。
      参数:
      op - 用于结合通道值的操作
      e1 - 输入标量
      v2 - 另一个输入向量
      m - 控制通道选择的掩码
      返回:
      将操作应用于输入向量和标量的结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • add

      public final IntVector add(Vector<Integer> v)
      将此向量添加到第二个输入向量。这是一种通道级二元操作，将原始加法操作（+）应用于每对对应的通道值。此方法也等同于表达式lanewise(ADD, v)。

      作为一个全功能命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（掩码和非掩码均有）。

      指定者:
      add 在类 Vector<Integer>
      参数:
      v - 第二个输入向量
      返回:
      将此向量添加到第二个输入向量的结果
      参见:

    • add

      public final IntVector add(int e)
      将此向量添加到输入标量的广播。这是一种通道级二元操作，将原始加法操作（+）应用于每个通道。此方法也等同于表达式lanewise(ADD, e)。
      参数:
      e - 输入标量
      返回:
      将此向量的每个通道添加到标量的结果
      参见:

    • add

      public final IntVector add(Vector<Integer> v, VectorMask<Integer> m)
      将此向量添加到第二个输入向量，根据掩码选择通道。这是一种掩码通道级二元操作，将原始加法操作（+）应用于每对对应的通道值。对于掩码中未设置的任何通道，原始操作被抑制，此向量保留该通道中存储的原始值。此方法也等同于表达式lanewise(ADD, v, m)。

      作为一个全功能命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（掩码和非掩码均有）。

      指定者:
      add 在类 Vector<Integer>
      参数:
      v - 第二个输入向量
      m - 控制通道选择的掩码
      返回:
      将此向量添加到给定向量的结果
      参见:

    • add

      public final IntVector add(int e, VectorMask<Integer> m)
      将此向量添加到输入标量的广播，根据掩码选择通道元素。这是一种掩码通道级二元操作，将原始加法操作（+）应用于每个通道。此方法也等同于表达式lanewise(ADD, s, m)。
      参数:
      e - 输入标量
      m - 控制通道选择的掩码
      返回:
      将此向量的每个通道添加到标量的结果
      参见:

    • sub

      public final IntVector sub(Vector<Integer> v)
      从此向量中减去第二个输入向量。这是一种通道级二元操作，将原始减法操作（-）应用于每对对应的通道值。此方法也等同于表达式lanewise(SUB, v)。

      作为一个全功能命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（掩码和非掩码均有）。

      指定者:
      sub 在类 Vector<Integer>
      参数:
      v - 第二个输入向量
      返回:
      将第二个输入向量从此向量中减去的结果
      参见:

    • sub

      public final IntVector sub(int e)
      从此向量中减去一个输入标量。这是一种掩码式的逐个通道二进制操作，它对每个通道应用原始减法操作（-）。此方法还等同于表达式lanewise(SUB, e)。
      参数:
      e - 输入标量
      返回值:
      从每个通道的向量中减去标量的结果
      参见:

    • sub

      public final IntVector sub(Vector<Integer> v, VectorMask<Integer> m)
      从此向量中减去第二个输入向量，受掩码控制。这是一种掩码式的逐个通道二进制操作，它对每对对应通道值应用原始减法操作（-）。对于掩码中未设置的任何通道，原始操作被抑制，此向量保留该通道中存储的原始值。此方法还等同于表达式lanewise(SUB, v, m)。

      作为一个全服务命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（掩码和非掩码）。

      指定者:
      sub 在类 Vector<Integer>
      参数:
      v - 第二个输入向量
      m - 控制通道选择的掩码
      返回值:
      从第二个输入向量减去此向量的结果
      参见:

    • sub

      public final IntVector sub(int e, VectorMask<Integer> m)
      从此向量中减去一个输入标量，受掩码控制。这是一种掩码式的逐个通道二进制操作，它对每个通道应用原始减法操作（-）。此方法还等同于表达式lanewise(SUB, s, m)。
      参数:
      e - 输入标量
      m - 控制通道选择的掩码
      返回值:
      从此向量的每个通道减去标量的结果
      参见:

    • mul

      public final IntVector mul(Vector<Integer> v)
      将此向量乘以第二个输入向量。这是一种逐个通道二进制操作，它对每对对应通道值应用原始乘法操作（*）。此方法还等同于表达式lanewise(MUL, v)。

      作为一个全服务命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（掩码和非掩码）。

      指定者:
      mul 在类 Vector<Integer>
      参数:
      v - 第二个输入向量
      返回值:
      将此向量乘以第二个输入向量的结果
      参见:

    • mul

      public final IntVector mul(int e)
      将此向量乘以输入标量的广播。这是一种逐个通道二进制操作，它对每个通道应用原始乘法操作（*）。此方法还等同于表达式lanewise(MUL, e)。
      参数:
      e - 输入标量
      返回值:
      将此向量乘以给定标量的结果
      参见:

    • mul

      public final IntVector mul(Vector<Integer> v, VectorMask<Integer> m)
      将此向量乘以第二个输入向量，受掩码控制。这是一种逐个通道二进制操作，它对每对对应通道值应用原始乘法操作（*）。对于掩码中未设置的任何通道，原始操作被抑制，此向量保留该通道中存储的原始值。此方法还等同于表达式lanewise(MUL, v, m)。

      作为一个全服务命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（掩码和非掩码）。

      指定者:
      mul 在类 Vector<Integer>
      参数:
      v - 第二个输入向量
      m - 控制通道选择的掩码
      返回值:
      将此向量乘以给定向量的结果
      参见:

    • mul

      public final IntVector mul(int e, VectorMask<Integer> m)
      将此向量乘以输入标量的广播，选择由掩码控制的通道元素。这是一种掩码式的逐个通道二进制操作，它对每个通道应用原始乘法操作（*）。此方法还等同于表达式lanewise(MUL, s, m)。
      参数:
      e - 输入标量
      m - 控制通道选择的掩码
      返回值:
      将此向量的每个通道乘以标量的结果
      参见:

    • div

      public final IntVector div(Vector<Integer> v)
      将此向量除以第二个输入向量。这是一种逐个通道二进制操作，它对每对对应通道值应用原始除法操作（/）。此方法还等同于表达式lanewise(DIV, v)。

      作为一个全服务命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（掩码和非掩码）。

      指定者:
      div 在类 Vector<Integer>中
      API注释:
      如果存在零除数，将抛出 ArithmeticException。
      参数:
      v - 第二个输入向量
      返回值:
      将此向量除以第二个输入向量的结果
      参见:

    • div

      public final IntVector div(int e)
      将此向量除以输入标量的广播。这是一种逐个通道的二进制操作，对每个通道应用原始除法操作（/）。该方法也等同于表达式lanewise(DIV, e)。
      API注释:
      如果存在零除数，将抛出 ArithmeticException。
      参数:
      e - 输入标量
      返回值:
      将此向量的每个通道除以标量的结果
      参见:

    • div

      public final IntVector div(Vector<Integer> v, VectorMask<Integer> m)
      将此向量除以第二个输入向量，并受到掩码的控制。这是一种逐个通道的二进制操作，对每对对应通道值应用原始除法操作（/）。对于掩码中未设置的任何通道，将抑制原始操作，此向量保留该通道中存储的原始值。该方法也等同于表达式lanewise(DIV, v, m)。

      作为一个全服务命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（掩码和非掩码）。

      指定者:
      div 在类 Vector<Integer>中
      API注释:
      如果存在零除数，将抛出 ArithmeticException。
      参数:
      v - 第二个输入向量
      m - 控制通道选择的掩码
      返回值:
      将此向量除以第二个输入向量的结果
      参见:

    • div

      public final IntVector div(int e, VectorMask<Integer> m)
      将此向量除以输入标量的广播，选择由掩码控制的通道元素。这是一种掩码的逐个通道的二进制操作，对每个通道应用原始除法操作（/）。该方法也等同于表达式lanewise(DIV, s, m)。
      API注释:
      如果存在零除数，将抛出 ArithmeticException。
      参数:
      e - 输入标量
      m - 控制通道选择的掩码
      返回值:
      将此向量的每个通道除以标量的结果
      参见:

    • min

      public final IntVector min(Vector<Integer> v)
      计算此向量和第二个输入向量中较小的值。这是一种逐个通道的二进制操作，对每对对应通道值应用操作Math.min()。该方法也等同于表达式lanewise(MIN, v)。
      指定者:
      min 在类 Vector<Integer>中
      参数:
      v - 第二个输入向量
      返回值:
      此向量和第二个输入向量的每个通道的最小值
      参见:

    • min

      public final IntVector min(int e)
      计算此向量和输入标量的广播中较小的值。这是一种逐个通道的二进制操作，对每对对应通道值应用操作Math.min()。该方法也等同于表达式lanewise(MIN, e)。
      参数:
      e - 输入标量
      返回值:
      将此向量乘以给定标量的结果
      参见:

    • max

      public final IntVector max(Vector<Integer> v)
      计算此向量和第二个输入向量中较大的值。这是一种逐个通道的二进制操作，对每对对应通道值应用操作Math.max()。该方法也等同于表达式lanewise(MAX, v)。

      这不像add()那样是一个全服务命名操作。此操作的掩码版本不是直接可用的，但可以通过lanewise的掩码版本获得。子类定义了此方法的额外标量广播重载。

      指定者:
      max 在类 Vector<Integer>中
      参数:
      v - 第二个输入向量
      返回值:
      此向量和第二个输入向量的每个通道的最大值
      参见:

    • max

      public final IntVector max(int e)
      计算此向量和输入标量的广播中较大的值。这是一种逐个通道的二进制操作，对每对对应通道值应用操作Math.max()。该方法也等同于表达式lanewise(MAX, e)。
      参数:
      e - 输入标量
      返回:
      将此向量乘以给定标量的结果
      参见:

    • and

      public final IntVector and(Vector<Integer> v)
      计算此向量与第二个输入向量的按位逻辑与（&）。这是一种按通道进行的二进制操作，将原始按位“与”操作（&）应用于每对对应通道值。此方法也等同于表达式lanewise(AND, v)。

      这不是像add那样的全功能命名操作。此操作的掩码版本不直接可用，但可以通过lanewise的掩码版本获得。

      参数:
      v - 第二个输入向量
      返回:
      此向量与第二个输入向量的按位&
      参见:

    • and

      public final IntVector and(int e)
      计算此向量与标量的按位逻辑与（&）。这是一种按通道进行的二进制操作，将原始按位“与”操作（&）应用于每对对应通道值。此方法也等同于表达式lanewise(AND, e)。
      参数:
      e - 输入标量
      返回:
      此向量与标量的按位&
      参见:

    • or

      public final IntVector or(Vector<Integer> v)
      计算此向量与第二个输入向量的按位逻辑或（|）。这是一种按通道进行的二进制操作，将原始按位“或”操作（|）应用于每对对应通道值。此方法也等同于表达式lanewise(AND, v)。

      这不是像add那样的全功能命名操作。此操作的掩码版本不直接可用，但可以通过lanewise的掩码版本获得。

      参数:
      v - 第二个输入向量
      返回:
      此向量与第二个输入向量的按位|
      参见:

    • or

      public final IntVector or(int e)
      计算此向量与标量的按位逻辑或（|）。这是一种按通道进行的二进制操作，将原始按位“或”操作（|）应用于每对对应通道值。此方法也等同于表达式lanewise(OR, e)。
      参数:
      e - 输入标量
      返回:
      此向量与标量的按位|
      参见:

    • neg

      public final IntVector neg()
      取反此向量。这是一种按通道进行的一元操作，将原始取反操作（-x）应用于每个输入通道。此方法也等同于表达式lanewise(NEG)。
      指定者:
      neg 在类 Vector<Integer>
      返回:
      此向量的取反
      参见:

    • abs

      public final IntVector abs()
      返回此向量的绝对值。这是一种按通道进行的一元操作，将方法Math.abs应用于每个输入通道。此方法也等同于表达式lanewise(ABS)。
      指定者:
      abs 在类 Vector<Integer>
      返回:
      此向量的绝对值
      参见:

    • not

      public final IntVector not()
      计算此向量的按位逻辑补（~）。这是一种按通道进行的二进制操作，将原始按位“非”操作（~）应用于每个通道值。此方法也等同于表达式lanewise(NOT)。

      这不是像add那样的全功能命名操作。此操作的掩码版本不直接可用，但可以通过lanewise的掩码版本获得。

      返回:
      此向量的按位补码~
      参见:

    • eq

      public final VectorMask<Integer> eq(Vector<Integer> v)
      测试此向量是否等于另一个输入向量。这是一种按通道进行的二进制测试操作，将原始等于操作（==）应用于每对对应通道值。结果与compare(VectorOperators.EQ, v)相同。
      指定者:
      eq 在类 Vector<Integer>
      参数:
      v - 第二个输入向量
      返回:
      测试每个通道是否等于第二个输入向量的掩码结果
      参见:

    • eq

      public final VectorMask<Integer> eq(int e)
      测试此向量是否等于输入标量。这是一种按通道进行的二进制测试操作，将原始等于操作（==）应用于每个通道。结果与compare(VectorOperators.Comparison.EQ, e)相同。
      参数:
      e - 输入标量
      返回:
      测试此向量是否等于e的结果掩码
      参见:

    • lt

      public final VectorMask<Integer> lt(Vector<Integer> v)
      测试此向量是否小于另一个输入向量。这是一种逐个通道的二进制测试操作，将原始小于操作(<)应用于每个通道。结果与compare(VectorOperators.LT, v)相同。
      指定者:
      lt 在类 Vector<Integer>
      参数:
      v - 第二个输入向量
      返回:
      测试此向量是否小于第二个输入向量的结果掩码
      参见:

    • lt

      public final VectorMask<Integer> lt(int e)
      测试此向量是否小于输入标量。这是一种逐个通道的二进制测试操作，将原始小于操作(<)应用于每个通道。结果与compare(VectorOperators.LT, e)相同。
      参数:
      e - 输入标量
      返回:
      测试此向量是否小于输入标量的结果掩码
      参见:

    • test

      public abstract VectorMask<Integer> test(VectorOperators.Test op)
      测试此向量的通道，根据给定的操作。这是一种逐个通道的一元测试操作，将给定的测试操作应用于每个通道值。
      指定者:
      test 在类 Vector<Integer>
      参数:
      op - 用于测试通道值的操作
      返回:
      测试此向量的通道的结果掩码，根据所选的测试运算符
      参见:

    • test

      public abstract VectorMask<Integer> test(VectorOperators.Test op, VectorMask<Integer> m)
      根据给定操作测试此向量的选定通道。这是一种带掩码的逐个通道的一元测试操作，将给定的测试操作应用于每个通道值。返回的结果等同于表达式test(op).and(m)。
      指定者:
      test 在类 Vector<Integer>
      参数:
      op - 用于测试通道值的操作
      m - 控制通道选择的掩码
      返回:
      测试此向量的通道的结果掩码，根据所选的测试运算符，并且仅在掩码选择的通道中
      参见:

    • compare

      public abstract VectorMask<Integer> compare(VectorOperators.Comparison op, Vector<Integer> v)
      通过将其与另一个输入向量进行比较，根据给定的比较操作测试此向量。这是一种逐个通道的二进制测试操作，将给定的比较操作应用于每对对应的通道值。
      指定者:
      compare 在类 Vector<Integer>
      参数:
      op - 用于比较通道值的操作
      v - 第二个输入向量
      返回:
      测试此向量是否与输入进行比较的结果掩码，根据所选的比较运算符
      参见:

    • compare

      public abstract VectorMask<Integer> compare(VectorOperators.Comparison op, int e)
      通过将其与输入标量进行比较，根据给定的比较操作测试此向量。这是一种逐个通道的二进制测试操作，将比较操作应用于每个通道。

      结果与compare(op, broadcast(species(), e))相同。也就是说，标量可以被视为广播到相同种类的向量，然后与原始向量进行比较，使用所选的比较操作。

      参数:
      op - 用于比较通道值的操作
      e - 输入标量
      返回:
      测试此向量是否与输入进行比较的结果掩码，根据所选的比较运算符
      参见:

    • compare

      public final VectorMask<Integer> compare(VectorOperators.Comparison op, int e, VectorMask<Integer> m)
      通过将其与输入标量进行比较，根据给定的比较操作，在由掩码选择的通道中测试此向量。这是一种带掩码的逐个通道的二进制测试操作，应用于每对应的通道值。返回的结果等同于表达式compare(op,s).and(m)。
      参数:
      op - 用于比较通道值的操作
      e - 输入标量
      m - 控制通道选择的掩码
      返回:
      测试此向量是否与输入进行比较的结果掩码，根据所选的比较运算符，并且仅在掩码选择的通道中
      参见:

    • compare

      public abstract VectorMask<Integer> compare(VectorOperators.Comparison op, long e)
      通过将其与输入标量进行比较，根据给定的比较操作测试此向量。这是一种逐个通道的二进制测试操作，将给定的比较操作应用于每个通道值，与广播值配对。

      结果与this.compare(op, this.broadcast(e))相同。也就是说，标量可以被视为广播到相同种类的向量，然后与原始向量进行比较，使用所选的比较操作。

      指定者:
      compare 在类 Vector<Integer>
      参数:
      op - 用于比较通道值的操作
      e - 输入标量
      返回:
      测试此向量是否与输入进行比较的结果掩码，根据所选的比较运算符
      参见:

    • compare

      public final VectorMask<Integer> compare(VectorOperators.Comparison op, long e, VectorMask<Integer> m)
      通过将其与输入标量进行比较，根据给定的比较操作，在由掩码选择的通道中测试此向量。这是一种带掩码的逐个通道的二进制测试操作，将给定的比较操作应用于每个通道值，与广播值配对。返回的结果等同于表达式compare(op,e).and(m)。
      指定者:
      compare 在类 Vector<Integer>中
      参数:
      op - 用于比较通道值的操作
      e - 输入标量
      m - 控制通道选择的掩码
      返回值:
      测试每个通道是否根据所选比较运算符与输入向量进行比较的掩码结果，仅在掩码选择的通道中
      参见:

    • blend

      public abstract IntVector blend(Vector<Integer> v, VectorMask<Integer> m)
      用第二个输入向量中对应通道的值替换此向量的选定通道。这是一种受掩码控制的通道级二进制操作，从一个输入或另一个输入中选择每个通道的值。
      • 对于掩码中设置的任何通道，新的通道值来自第二个输入向量，并替换此向量中该通道中的任何值。
      • 对于掩码中未设置的任何通道，替换被抑制，此向量保留该通道中原始值。
      以下伪代码说明了这种行为： 
      
 Vector<E> a = ...;
 VectorSpecies<E> species = a.species();
 Vector<E> b = ...;
 b.check(species);
 VectorMask<E> m = ...;
 ETYPE[] ar = a.toArray();
 for (int i = 0; i < ar.length; i++) {
     if (m.laneIsSet(i)) {
         ar[i] = b.lane(i);
     }
 }
 return EVector.fromArray(s, ar, 0);
      指定者:
      blend 在类 Vector<Integer>中
      参数:
      v - 第二个输入向量，包含替换通道值
      m - 控制从第二个输入向量选择通道的掩码
      返回值:
      将此向量的通道元素与第二个输入向量的通道元素混合的结果

    • addIndex

      public abstract IntVector addIndex(int scale)
      将此向量的通道与其对应的通道号相加，按给定的常数进行缩放。这是一种通道级一元操作，对于每个通道N，计算缩放索引值N*scale并将其添加到当前向量的通道N中的值。

      缩放值不能太大，元素大小不能太小，以至于在使用矢量通道类型ETYPE表示结果时计算任何N*scale或VLENGTH*scale时会发生溢出。

      以下伪代码说明了这种行为：

      
 Vector<E> a = ...;
 VectorSpecies<E> species = a.species();
 ETYPE[] ar = a.toArray();
 for (int i = 0; i < ar.length; i++) {
     long d = (long)i * scale;
     if (d != (ETYPE) d)  throw ...;
     ar[i] += (ETYPE) d;
 }
 long d = (long)ar.length * scale;
 if (d != (ETYPE) d)  throw ...;
 return EVector.fromArray(s, ar, 0);
      指定者:
      addIndex 在类 Vector<Integer>中
      参数:
      scale - 用于将每个通道索引N乘以的数字，通常为1
      返回值:
      将每个通道元素递增其对应的通道索引N乘以scale的结果

    • blend

      public final IntVector blend(int e, VectorMask<Integer> m)
      用标量值替换此向量的选定通道，受掩码控制。这是一种受掩码控制的通道级二进制操作，从一个输入或另一个输入中选择每个通道的值。返回的结果等于表达式blend(broadcast(e),m)。
      参数:
      e - 包含替换通道值的输入标量
      m - 控制标量通道选择的掩码
      返回值:
      将此向量的通道元素与标量值混合的结果

    • blend

      public final IntVector blend(long e, VectorMask<Integer> m)
      用标量值替换此向量的选定通道，受掩码控制。这是一种受掩码控制的通道级二进制操作，从一个输入或另一个输入中选择每个通道的值。返回的结果等于表达式blend(broadcast(e),m)。
      指定者:
      blend 在类 Vector<Integer>中
      参数:
      e - 包含替换通道值的输入标量
      m - 控制标量通道选择的掩码
      返回值:
      将此向量的通道元素与标量值混合的结果

    • slice

      public abstract IntVector slice(int origin, Vector<Integer> v1)
      从当前向量中的给定origin通道开始，切片相邻通道的段，并继续（如有必要）进入紧随其后的向量。将VLENGTH个通道块提取到自己的向量中并返回。

      这是一种跨通道操作，将通道元素从当前向量和第二个向量中移至前端。这两个向量可以被视为长度为2*VLENGTH的组合“背景”，从中提取一个切片。输出向量中编号为N的通道从输入向量的通道origin+N复制，如果该通道存在，则从第二个向量的通道origin+N-VLENGTH复制（保证存在）。

      origin值必须在包含范围0..VLENGTH内。作为极端情况，v.slice(0,w)和v.slice(VLENGTH,w)分别返回v和w。

      参数:
      origin - 要传输到切片中的第一个输入通道
      v1 - 逻辑上与第一个向量连接，然后进行切片（如果省略，默认为零）
      返回值:
      从此向量开始的指定起点处切片的连续VLENGTH个通道，继续（如有必要）进入第二个向量
      参见:

    • slice

      public final IntVector slice(int origin, Vector<Integer> w, VectorMask<Integer> m)
      在受掩码控制下，从当前向量中的给定origin通道开始，切片相邻通道，并继续（如有必要）进入紧随其后的向量。将VLENGTH个通道块提取到自己的向量中并返回。结果向量中未设置的通道将为零。在掩码中设置的通道将包含从所选通道的this或v1复制的数据。

      这是一种跨通道操作，将通道元素从当前向量和第二个向量中移至前端。这两个向量可以被视为长度为2*VLENGTH的组合“背景”，从中提取一个切片。返回的结果等于表达式broadcast(0).blend(slice(origin,v1),m)。

      指定者:
      slice 在类 Vector<Integer>中
      参数:
      origin - 要传输到切片中的第一个输入通道
      w - 逻辑上与第一个向量连接，然后进行切片（如果省略，默认为零）
      m - 控制将通道选择到结果向量中的掩码
      返回值:
      从此向量开始的指定起点处切片的连续VLENGTH个通道，继续（如有必要）进入第二个向量
      参见:

    • slice

      public abstract IntVector slice(int origin)
      从当前向量中的给定origin通道开始，切片相邻通道。从一个向量中提取一个VLENGTH通道块，可能填充零通道，并将其放入自己的向量中并返回。这是一个方便的方法，从一个单一向量中切片，针对零通道的扩展背景。等同于slice (origin, broadcast(0))。也可以简单地将其视为从后向前通道的跨通道移位，零填充在向量末尾的空出通道中。在这种视图中，移位计数为origin。
      参数:
      origin - 要传输到切片中的第一个输入通道
      返回值:
      最后的VLENGTH-origin个输入通道，从第一个输出通道开始放置，末尾填充零
      参见:

    • unslice

      public abstract IntVector unslice(int origin, Vector<Integer> w, int part)
      反转slice()，将当前向量作为一个切片插入到另一个“背景”输入向量中，该向量被视为假设的后续slice()操作的一个输入。

      这是一个跨通道操作，将当前向量的通道元素向后排列，并将它们插入到逻辑背景向量对中。然而，只返回一对中的一个。背景由复制第二个输入向量形成。（但是，输出永远不会包含来自同一输入通道的两个重复项。）输入向量中编号为N的通道被复制到第一个背景向量的通道origin+N中，如果该通道存在，则复制到第二个背景向量的通道origin+N-VLENGTH中（保证存在）。更新后插入切片的第一个或第二个背景向量将被返回。零或一的part数选择第一个或第二个更新后的背景向量。

      origin值必须在包含范围0..VLENGTH内。作为极端情况，v.unslice(0,w,0)和v.unslice(VLENGTH,w,1)都返回v，而v.unslice(0,w,1)和v.unslice(VLENGTH,w,0)都返回w。

      指定者：
      unslice 在类中 Vector<Integer>
      参数：
      origin - 接收切片的第一个输出通道
      w - 将接收插入切片的“背景”向量（作为两个副本）
      part - 结果的部分编号（零或一）
      返回：
      两个背景向量对中的第一个或第二个部分，通过在指定的起始位置插入此向量进行更新
      参见：

    • unslice

      public abstract IntVector unslice(int origin, Vector<Integer> w, int part, VectorMask<Integer> m)
      反转slice()，在掩码的控制下，将当前向量作为一个切片插入到另一个“背景”输入向量中，该向量被视为假设的后续slice()操作的一个输入。

      这是一个跨通道操作，将当前向量的通道元素向前排列，并将其通道（由掩码选择）插入到逻辑背景向量对中。与此方法的未掩码版本相比，只返回一对中的一个，由part编号选择。对于掩码选择的每个通道N，如果该通道存在，则将通道值复制到第一个背景向量的通道origin+N中，否则将通道值复制到第二个背景向量的通道origin+N-VLENGTH中（保证存在）。如果相应的输入通道N在掩码中未设置，则背景通道保留其原始值。更新后插入切片的第一个或第二个背景向量将被返回。零或一的part数选择第一个或第二个更新后的背景向量。

      指定者：
      unslice 在类中 Vector<Integer>
      参数：
      origin - 接收切片的第一个输出通道
      w - 将接收插入切片的“背景”向量（作为两个副本），如果它们在m中被设置
      part - 结果的部分编号（零或一）
      m - 控制从当前向量中选择通道的掩码
      返回：
      两个背景向量对中的第一个或第二个部分，通过在指定的起始位置插入此向量的选定通道进行更新
      参见：

    • unslice

      public abstract IntVector unslice(int origin)
      反转slice()，将当前向量作为一个切片插入到一个全为零的“背景”输入中。与其他unslice()方法相比，此方法仅返回背景向量对中的第一个。这是一个便利方法，返回unslice (origin, broadcast(0), 0)的结果。也可以简单地将其视为从早期到后期通道的跨通道移位，零填充在向量开头的空通道中。在这种视图中，移位计数为origin。
      指定者：
      unslice 在类中 Vector<Integer>
      参数：
      origin - 接收切片的第一个输出通道
      返回：
      从给定起始位置开始放置的第一个VLENGTH-origin输入通道，开头填充为零
      参见：

    • rearrange

      public abstract IntVector rearrange(VectorShuffle<Integer> m)
      重新排列此向量的通道元素，选择在特定洗牌控制下的通道。这是一个跨通道操作，重新排列此向量的通道元素。对于每个洗牌的通道N，以及每个洗牌中的通道源索引I=s.laneSource(N)，输出通道N从输入向量的通道I获取值。
      指定者：
      rearrange 在类中 Vector<Integer>
      参数：
      m - 控制通道索引选择的洗牌
      返回：
      重新排列此向量的通道元素
      参见：

    • rearrange

      public abstract IntVector rearrange(VectorShuffle<Integer> s, VectorMask<Integer> m)
      重新排列此向量的通道元素，选择在特定洗牌和掩码控制下的通道。这是一个跨通道操作，重新排列此向量的通道元素。对于每个洗牌的通道N，以及每个洗牌中的通道源索引I=s.laneSource(N)，如果掩码被设置，则输出通道N从输入向量的通道I获取值。否则，如果掩码未设置，则输出通道N设置为零。

      此方法返回以下伪代码的值：

      
 Vector<E> r = this.rearrange(s.wrapIndexes());
 VectorMask<E> valid = s.laneIsValid();
 if (m.andNot(valid).anyTrue()) throw ...;
 return broadcast(0).blend(r, m);
      指定者：
      rearrange 在类中 Vector<Integer>
      参数：
      s - 控制通道索引选择的洗牌
      m - 控制洗牌应用的掩码
      返回：
      重新排列此向量的通道元素
      参见：

    • rearrange

      public abstract IntVector rearrange(VectorShuffle<Integer> s, Vector<Integer> v)
      重新排列两个向量的通道元素，使用特定洗牌的正常和异常索引来引导数据。这是一个跨通道操作，重新排列两个输入向量（当前向量和第二个向量v）的通道元素。对于每个洗牌的通道N，以及每个洗牌中的通道源索引I=s.laneSource(N)，如果I>=0，则输出通道N从第一个向量的通道I获取值。否则，异常索引I通过添加VLENGTH进行包装，并用于索引第二个向量，索引为I+VLENGTH。

      此方法返回以下伪代码的值：

      
 Vector<E> r1 = this.rearrange(s.wrapIndexes());
 // 或者：r1 = this.rearrange(s, s.laneIsValid());
 Vector<E> r2 = v.rearrange(s.wrapIndexes());
 return r2.blend(r1,s.laneIsValid());
      指定者:
      rearrange 在类 Vector<Integer>中
      参数:
      s - 控制来自两个输入向量的通道选择的洗牌
      v - 第二个输入向量
      返回值:
      该向量及第二个输入向量的通道元素重新排列
      参见:

    • compress

      public abstract IntVector compress(VectorMask<Integer> m)
      压缩该向量的通道元素，选择由特定掩码控制的通道。这是一个跨通道操作，根据指定的掩码压缩该向量的通道元素。对于掩码的每个通道 N，如果通道 N 处的掩码被设置，则选择输入向量在通道 N 处的元素，并连续存储到输出向量从通道 0 开始。输出向量的所有剩余上部通道（如果有）将设置为零。
      指定者:
      compress 在类 Vector<Integer>中
      参数:
      m - 控制压缩的掩码
      返回值:
      该向量的压缩通道元素
      自 JDK 版本:
      19

    • expand

      public abstract IntVector expand(VectorMask<Integer> m)
      在特定掩码的控制下，扩展该向量的通道元素。这是一个跨通道操作，根据指定的掩码将该向量的连续通道元素扩展到输出向量的通道中。对于掩码的每个通道 N，如果掩码在通道 N 处被设置，则从通道 0 开始选择输入向量的下一个连续元素，并将其存储到输出向量的通道 N 处。输出向量的所有剩余通道（如果有）将设置为零。
      指定者:
      expand 在类 Vector<Integer>中
      参数:
      m - 控制扩展的掩码
      返回值:
      该向量的扩展通道元素
      自 JDK 版本:
      19

    • selectFrom

      public abstract IntVector selectFrom(Vector<Integer> v)
      使用存储在该向量的通道中的索引值，组装存储在第二个向量 v 中的值。因此，第二个向量充当一个表，其元素由当前向量中的索引选择。这是一个跨通道操作，根据该向量的控制重新排列参数向量的通道元素。对于该向量的每个通道 N，以及该向量中通道值 I=this.lane(N)，输出通道 N 获取来自参数向量在通道 I 处的值。通过这种方式，结果仅包含存储在参数向量 v 中的值，但呈现的顺序取决于 this 中的索引值。结果与表达式 v.rearrange(this.toShuffle()) 相同。
      指定者:
      selectFrom 在类 Vector<Integer>中
      参数:
      v - 提供结果值的向量
      返回值:
      v 的通道元素重新排列
      参见:

    • selectFrom

      public abstract IntVector selectFrom(Vector<Integer> s, VectorMask<Integer> m)
      使用存储在该向量的通道中的索引值，组装存储在第二个向量中的值，受掩码控制。使用存储在该向量的通道中的索引值，组装存储在第二个向量 v 中的值。因此，第二个向量充当一个表，其元素由当前向量中的索引选择。在掩码中未设置的通道将接收零而不是来自表的值。这是一个跨通道操作，根据该向量和掩码的控制重新排列参数向量的通道元素。结果与表达式 v.rearrange(this.toShuffle(), m) 相同。
      指定者:
      selectFrom 在类 Vector<Integer>中
      参数:
      s - 提供结果值的向量
      m - 控制从 v 中选择的掩码
      返回值:
      v 的通道元素重新排列
      参见:

    • bitwiseBlend

      public final IntVector bitwiseBlend(Vector<Integer> bits, Vector<Integer> mask)
      在第三个向量的控制下，将两个向量的位混合在一起，该向量提供掩码位。这是一个逐通道三元操作，对每个通道执行位混合操作 (a&~c)|(b&c)。该方法也等同于表达式 lanewise(BITWISE_BLEND, bits, mask)。
      参数:
      bits - 要混合到当前向量中的输入位
      mask - 位掩码，用于启用输入位的混合
      返回值:
      将给定位的位混合到当前向量中，受位掩码控制
      参见:

    • bitwiseBlend

      public final IntVector bitwiseBlend(int bits, int mask)
      在另一个标量的控制下，将一个向量和一个标量的位混合在一起，该向量提供掩码位。这是一个逐通道三元操作，对每个通道执行位混合操作 (a&~c)|(b&c)。该方法也等同于表达式 lanewise(BITWISE_BLEND, bits, mask)。
      参数:
      bits - 要混合到当前向量中的输入位
      mask - 位掩码，用于启用输入位的混合
      返回值:
      将给定位的位混合到当前向量中，受位掩码控制
      参见:

    • bitwiseBlend

      public final IntVector bitwiseBlend(int bits, Vector<Integer> mask)
      在另一个向量的控制下，将一个向量和一个标量的位混合在一起，该向量提供掩码位。这是一个逐通道三元操作，对每个通道执行位混合操作 (a&~c)|(b&c)。该方法也等同于表达式 lanewise(BITWISE_BLEND, bits, mask)。
      参数:
      bits - 要混合到当前向量中的输入位
      mask - 位掩码，用于启用输入位的混合
      返回值:
      将给定位的位混合到当前向量中，受位掩码控制
      参见:

    • bitwiseBlend

      public final IntVector bitwiseBlend(Vector<Integer> bits, int mask)
      将两个向量的位混合在标量的控制下，标量提供掩码位。这是一个按lane进行的三元操作，对每个lane执行位混合操作 (a&~c)|(b&c)。该方法也等同于表达式 lanewise(BITWISE_BLEND, bits, mask)。
      参数:
      bits - 要混合到当前向量中的输入位
      mask - 用于启用输入位混合的位掩码
      返回:
      将给定位按位混合到当前向量中，受位掩码控制
      参见:

    • reduceLanes

      public abstract int reduceLanes(VectorOperators.Associative op)
      返回从此向量的所有lane累积的值。这是一个关联的跨lane缩减操作，将指定的操作应用于所有lane元素。

      一些缩减操作不支持其操作数的任意重新排序，但由于其有用性而包含在此处。

      • 在 FIRST_NONZERO 的情况下，缩减将返回从最低编号的非零lane返回的值。
      • 所有其他缩减操作都是完全可交换和关联的。实现可以选择任何处理顺序，但它将始终产生相同的结果。
      参数:
      op - 用于组合lane值的操作
      返回:
      累积的结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • reduceLanes

      public abstract int reduceLanes(VectorOperators.Associative op, VectorMask<Integer> m)
      返回从此向量的选定lane累积的值，由掩码控制。这是一个关联的跨lane缩减操作，将指定的操作应用于选定的lane元素。

      如果没有选择元素，则返回特定于操作的身份值。

      • 如果操作是 ADD、XOR、OR 或 FIRST_NONZERO，则身份值为零，即默认的 int 值。
      • 如果操作是 MUL，则身份值为一。
      • 如果操作是 AND，则身份值为负一（所有位设置）。
      • 如果操作是 MAX，则身份值为 Integer.MIN_VALUE。
      • 如果操作是 MIN，则身份值为 Integer.MAX_VALUE。

      一些缩减操作不支持其操作数的任意重新排序，但由于其有用性而包含在此处。

      • 在 FIRST_NONZERO 的情况下，缩减将返回从最低编号的非零lane返回的值。
      • 所有其他缩减操作都是完全可交换和关联的。实现可以选择任何处理顺序，但它将始终产生相同的结果。
      参数:
      op - 用于组合lane值的操作
      m - 控制lane选择的掩码
      返回:
      从选定lane值累积的缩减结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • lane

      public abstract int lane(int i)
      获取lane索引为 i 的lane元素
      参数:
      i - lane索引
      返回:
      lane索引为 i 的lane元素
      抛出:
      IllegalArgumentException - 如果索引超出范围（< 0 || >= length()）

    • withLane

      public abstract IntVector withLane(int i, int e)
      用值 e 替换此向量在lane索引 i 处的lane元素。这是一个跨lane操作，行为就像返回将此向量与广播 e 和一个在lane索引 i 处设置了一个lane的掩码的输入向量混合的结果。
      参数:
      i - 要替换的lane元素的lane索引
      e - 要放置的值
      返回:
      用值 e 替换此向量在lane索引 i 处的lane元素的结果。
      抛出:
      IllegalArgumentException - 如果索引超出范围（< 0 || >= length()）

    • toArray

      public final int[] toArray()
      返回一个包含所有lane值的 int[] 类型数组。数组长度与向量长度相同。数组元素按lane顺序存储。

      此方法的行为就像将此向量存储到分配的数组中（使用 intoArray），并返回数组如下：

      
   int[] a = new int[this.length()];
   this.intoArray(a, 0);
   return a;
      指定者:
      toArray 在类 Vector<Integer>
      返回:
      包含此向量的lane值的数组
      参见:

    • toIntArray

      public final int[] toIntArray()
      返回一个包含所有lane值的 int[] 类型数组，转换为类型 int。数组长度与向量长度相同。数组元素按lane顺序转换并存储。 如果向量元素类型为 float 或 double，则此操作可能失败，当lanes包含小数或超出范围值时。如果任何向量lane值无法表示为 int，则会抛出异常。 这是 toArray() 的别名。当此方法用于类型为 IntVector 的向量时，不会丢失范围或精度。
      指定者:
      toIntArray 在类 Vector<Integer>
      返回:
      包含此向量的lane值的 int[] 数组
      参见:

    • toLongArray

      public final long[] toLongArray()
      返回一个包含所有lane值的 long[] 类型数组，转换为类型 long。数组长度与向量长度相同。数组元素按lane顺序转换并存储。 如果向量元素类型为 float 或 double，则此操作可能失败，当lanes包含小数或超出范围值时。如果任何向量lane值无法表示为 long，则会抛出异常。
      指定者:
      toLongArray 在类 Vector<Integer>
      实现注意:
      当此方法用于类型为 IntVector 的向量时，不会丢失精度或范围，因此不会抛出 UnsupportedOperationException。
      返回:
      包含此向量的lane值的 long[] 数组
      参见:

    • toDoubleArray

      public final double[] toDoubleArray()
      返回一个包含所有lane值的 double[] 类型数组，转换为类型 double。数组长度与向量长度相同。数组元素按lane顺序转换并存储。 如果向量元素类型为 long，则此操作可能会丢失精度。
      指定者:
      toDoubleArray 在类 Vector<Integer>中
      实现注意事项:
      当在类型为IntVector的向量上使用此方法时，不会丢失精度。
      返回:
      包含此向量的通道值的double[]数组，可能四舍五入以表示可表示的double值
      参见:

    • fromArray

      public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset)
      从类型为int[]的数组中的偏移量开始加载一个向量。对于每个向量通道，其中N是向量通道索引，索引offset + N处的数组元素被放入结果向量的通道索引N处。
      参数:
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量
      返回:
      从数组加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于向量中的任何通道N，offset+N < 0或offset+N >= a.length

    • fromArray

      public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset, VectorMask<Integer> m)
      从类型为int[]的数组中的偏移量开始使用掩码加载一个向量。掩码未设置的通道将填充为int（零）的默认值。对于每个向量通道，其中N是向量通道索引，如果掩码通道在索引N处设置，则将数组元素放入结果向量的通道索引N处，否则将默认元素值放入结果向量的通道索引N处。
      参数:
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量
      m - 控制通道选择的掩码
      返回:
      从数组加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于掩码设置的向量中的任何通道N，offset+N < 0或offset+N >= a.length

    • fromArray

      public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset)
      从类型为int[]的数组中收集一个新的向量，使用通过将固定offset添加到索引映射的一系列次要偏移量而获得的索引。索引映射是第二个int数组中从给定mapOffset开始的VLENGTH元素的连续序列。

      对于每个向量通道，其中N是向量通道索引，通道从数组元素a[f(N)]加载，其中f(N)是索引映射表达式offset + indexMap[mapOffset + N]]。

      参数:
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量，如果索引映射中的相对索引补偿以产生数组边界内的值，则可能为负
      indexMap - 索引映射
      mapOffset - 索引映射中的偏移量
      返回:
      从数组的索引元素加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于向量中的任何通道N，mapOffset+N < 0或mapOffset+N >= indexMap.length，或者如果f(N)=offset+indexMap[mapOffset+N]是a中的无效索引，对于向量中的任何通道N

    • fromArray

      public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)
      从类型为int[]的数组中收集一个新的向量，受掩码控制，并使用通过将固定offset添加到索引映射的一系列次要偏移量而获得的索引。索引映射是第二个int数组中从给定mapOffset开始的VLENGTH元素的连续序列。

      对于每个向量通道，其中N是向量通道索引，如果掩码中设置了通道，则从数组元素a[f(N)]加载通道，其中f(N)是索引映射表达式offset + indexMap[mapOffset + N]]。结果向量中未设置的通道将设置为零。

      参数:
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量，如果索引映射中的相对索引补偿以产生数组边界内的值，则可能为负
      indexMap - 索引映射
      mapOffset - 索引映射中的偏移量
      m - 控制通道选择的掩码
      返回:
      从数组的索引元素加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于设置了掩码的向量中的任何通道N，mapOffset+N < 0或mapOffset+N >= indexMap.length，或者如果f(N)=offset+indexMap[mapOffset+N]是a中的无效索引，对于向量中的任何通道N

    • fromMemorySegment

      public static IntVector fromMemorySegment(VectorSpecies<Integer> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)
      从预览开始加载一个向量，从内存段中的偏移量开始。字节根据指定的字节顺序组成原始通道元素。向量根据内存排序排列。

      此方法的行为就好像返回调用fromMemorySegment()预览的结果如下：

      
 var m = species.maskAll(true);
 return fromMemorySegment(species, ms, offset, bo, m);
      参数:
      species - 所需向量的种类
      ms - 内存段
      offset - 内存段中的偏移量
      bo - 预期的字节顺序
      返回:
      从内存段加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于向量中的任何通道N，offset+N*4 < 0或offset+N*4 >= ms.byteSize()
      IllegalArgumentException - 如果内存段是不由byte[]数组支持的堆段。
      IllegalStateException - 如果内存段的会话未激活，或者如果访问来自拥有会话的线程之外的线程。
      自:
      19

    • fromMemorySegment

      public static IntVector fromMemorySegment(VectorSpecies<Integer> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Integer> m)
      从预览开始加载一个向量，从内存段中的偏移量开始，并使用掩码。未设置掩码的通道将填充为int（零）的默认值。字节根据指定的字节顺序组成原始通道元素。向量根据内存排序排列。

      以下伪代码说明了行为：

      
 var slice = ms.asSlice(offset);
 int[] ar = new int[species.length()];
 for (int n = 0; n < ar.length; n++) {
     if (m.laneIsSet(n)) {
         ar[n] = slice.getAtIndex(ValuaLayout.JAVA_INT.withByteAlignment(1), n);
     }
 }
 IntVector r = IntVector.fromArray(species, ar, 0);
      实现注意事项:
      如果指定的字节顺序与平台本机顺序相同，则此操作可能更有效，因为此方法不需要重新排序通道值的字节。
      参数:
      species - 所需向量的种类
      ms - 内存段
      offset - 内存段中的偏移量
      bo - 预期的字节顺序
      m - 控制通道选择的掩码
      返回:
      从内存段加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于设置了掩码的向量中的任何通道N，offset+N*4 < 0或offset+N*4 >= ms.byteSize()
      IllegalArgumentException - 如果内存段是不由byte[]数组支持的堆段。
      IllegalStateException - 如果内存段的会话未激活，或者如果访问来自拥有会话的线程之外的线程。
      自:
      19

    • intoArray

      public final void intoArray(int[] a, int offset)
      将此向量存储到一个以偏移量开始的int[]类型的数组中。

      对于每个向量通道，其中N是向量通道索引，索引为N的通道元素存储到数组元素a[offset+N]中。

      参数:
      a - 数组，类型为int[]
      offset - 数组中的偏移量
      抛出:
      IndexOutOfBoundsException - 如果对于向量中的任何通道N，offset+N < 0或offset+N >= a.length

    • intoArray

      public final void intoArray(int[] a, int offset, VectorMask<Integer> m)
      将此向量存储到一个以偏移量开始并使用掩码的int[]类型的数组中。

      对于每个向量通道，其中N是向量通道索引，索引为N的通道元素存储到数组元素a[offset+N]中。如果N处的掩码通道未设置，则相应的数组元素a[offset+N]保持不变。

      对于设置了掩码的通道，将进行数组范围检查。未设置掩码的通道不会被存储，也不需要对应于a的合法元素。也就是说，未设置的通道可能对应于小于零或超出数组末尾的数组索引。

      参数:
      a - 数组，类型为int[]
      offset - 数组中的偏移量
      m - 控制通道存储的掩码
      抛出:
      IndexOutOfBoundsException - 如果对于设置了掩码的向量中的任何通道N，offset+N < 0或offset+N >= a.length

    • intoArray

      public final void intoArray(int[] a, int offset, int[] indexMap, int mapOffset)
      将此向量散射到一个int[]类型的数组中，使用通过将固定offset与从索引映射的一系列次要偏移相加而获得的索引。索引映射是第二个int数组中从给定mapOffset开始的VLENGTH元素的连续序列。

      对于每个向量通道，其中N是向量通道索引，索引为N的通道元素存储到数组元素a[f(N)]中，其中f(N)是索引映射表达式offset + indexMap[mapOffset + N]]。

      参数:
      a - 数组
      offset - 与索引映射偏移量相结合的偏移量
      indexMap - 索引映射
      mapOffset - 索引映射中的偏移量
      抛出:
      IndexOutOfBoundsException - 如果对于向量中的任何通道N，mapOffset+N < 0或mapOffset+N >= indexMap.length，或者对于向量中的任何通道N，f(N)=offset+indexMap[mapOffset+N]是a中的无效索引
      参见:

    • intoArray

      public final void intoArray(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)
      将此向量散射到一个int[]类型的数组中，受掩码控制，并使用通过将固定offset与从索引映射的一系列次要偏移相加而获得的索引。索引映射是第二个int数组中从给定mapOffset开始的VLENGTH元素的连续序列。

      对于每个向量通道，其中N是向量通道索引，如果索引为N的掩码通道已设置，则将索引为N的通道元素存储到数组元素a[f(N)]中，其中f(N)是索引映射表达式offset + indexMap[mapOffset + N]]。

      参数:
      a - 数组
      offset - 与索引映射偏移量相结合的偏移量
      indexMap - 索引映射
      mapOffset - 索引映射中的偏移量
      m - 掩码
      抛出:
      IndexOutOfBoundsException - 如果对于设置了掩码的向量中的任何通道N，mapOffset+N < 0或mapOffset+N >= indexMap.length，或者对于设置了掩码的向量中的任何通道N，f(N)=offset+indexMap[mapOffset+N]是a中的无效索引
      参见:

    • intoMemorySegment

      public final void intoMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo)
      将此向量存储到一个以偏移量开始并使用显式字节顺序的内存段PREVIEW中。

      根据指定的字节顺序从原始通道元素中提取字节。通道根据其内存顺序存储。

      此方法的行为就好像调用intoMemorySegment()PREVIEW如下：

      
 var m = maskAll(true);
 intoMemorySegment(ms, offset, bo, m);
      指定者:
      intoMemorySegment 在类 Vector<Integer>
      参数:
      ms - 内存段
      offset - 内存段中的偏移量
      bo - 预期的字节顺序
      自:
      19

    • intoMemorySegment

      public final void intoMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Integer> m)
      将此向量存储到一个以偏移量开始并使用显式字节顺序和掩码的内存段PREVIEW中。

      根据指定的字节顺序从原始通道元素中提取字节。通道根据其内存顺序存储。

      以下伪代码说明了行为，其中JAVA_E是原始元素类型的布局，ETYPE是原始元素类型，EVector是此向量的原始向量类型：

      
 ETYPE[] a = this.toArray();
 var slice = ms.asSlice(offset)
 for (int n = 0; n < a.length; n++) {
     if (m.laneIsSet(n)) {
         slice.setAtIndex(ValueLayout.JAVA_E.withBitAlignment(8), n);
     }
 }
      指定者:
      intoMemorySegment 在类 Vector<Integer>
      参数:
      ms - 内存段
      offset - 内存段中的偏移量
      bo - 预期的字节顺序
      m - 控制通道选择的掩码
      自:
      19

    • reinterpretAsBytes

      public final ByteVector reinterpretAsBytes()
      将此向量视为具有相同形状和内容但通道类型为byte的向量，其中字节根据小端顺序从通道中提取。这是一个方便的方法，用于表达式reinterpretShape(species().withLanes(byte.class))。它可以被认为是将字节合并到相同向量中的更大通道的各种方法的逆操作，例如Vector.reinterpretAsInts()。
      指定者:
      reinterpretAsBytes 在类 Vector<Integer>
      返回:
      一个具有相同形状和信息内容的ByteVector
      参见:

    • viewAsIntegralLanes

      public final IntVector viewAsIntegralLanes()
      将此向量视为具有相同形状、长度和内容，但通道类型不是浮点类型的向量。这是对通道值进行逐通道重新解释转换。因此，此方法不会更改VSHAPE或VLENGTH，向量的位内容也不会更改。如果向量的ETYPE已经是整数类型，则返回相同的向量。此方法返回以下表达式的值：convert(conv,0)，其中conv是VectorOperators.Conversion.ofReinterpret(E.class,F.class)，F是与E大小相同的非浮点类型。
      指定者：
      viewAsIntegralLanes 在类 Vector<Integer>中
      返回：
      将原始向量重新解释为非浮点数
      参见：

    • viewAsFloatingLanes

      public final FloatVector viewAsFloatingLanes()
      将此向量视为具有相同形状、长度和内容但是具有浮点类型的向量。这是对各个通道值进行重新解释的转换。因此，此方法不会更改VSHAPE或VLENGTH，向量的位内容也不会改变。如果向量的ETYPE已经是浮点类型，则返回相同的向量。如果向量的元素大小与任何浮点类型大小不匹配，则会抛出IllegalArgumentException。此方法返回此表达式的值：convert(conv,0)，其中conv是VectorOperators.Conversion.ofReinterpret(E.class,F.class)，F是与E大小相同的浮点类型（如果有的话）。
      指定者：
      viewAsFloatingLanes 在类 Vector<Integer>中
      返回：
      将原始向量重新解释为浮点数
      参见：

    • toString

      public final String toString()
      返回此向量的字符串表示形式，格式为"[0,1,2...]"，报告此向量的通道值，按通道顺序排列。生成的字符串就像通过调用Arrays.toString()一样，适用于由this.toArray()返回的int数组。
      指定者：
      toString 在类 Vector<Integer>中
      返回：
      以"[0,1,2...]"形式报告此向量的通道值的字符串

    • equals

      public final boolean equals(Object obj)
      指示此向量是否与其他对象相同。仅当两个向量具有相同的种类和相同的通道值（按相同顺序）时，它们才是相同的。

      通道值的比较就像通过调用Arrays.equals()一样，适用于两个向量上的toArray()返回的数组。

      指定者：
      equals 在类 Vector<Integer>中
      参数：
      obj - 要比较的参考对象
      返回：
      此向量是否与其他对象相同
      参见：

    • hashCode

      public final int hashCode()
      为向量生成基于通道值和向量种类的哈希码值。
      指定者：
      hashCode 在类 Vector<Integer>中
      返回：
      此向量的哈希码值
      参见：

    • species

      public final VectorSpecies<Integer> species()
      从类中复制的描述： Vector
      返回此向量的种类。
      指定者：
      species 在类 Vector<E>中
      返回：
      此向量的种类

    • check

      public final <F> Vector<F> check(VectorSpecies<F> species)
      从类中复制的描述： Vector
      检查此向量是否具有给定的种类，并返回此向量不变。效果类似于此伪代码：species == species() ? this : throw new ClassCastException()。
      指定者：
      check 在类 Vector<E>中
      类型参数：
      F - 所需种类的装箱元素类型
      参数：
      species - 所需种类
      返回：
      相同的向量
      参见：

    • check

      public final <F> Vector<F> check(Class<F> elementType)
      检查此向量是否具有给定的元素类型，并返回此向量不变。效果类似于此伪代码：elementType == species().elementType() ? this : throw new ClassCastException()。
      指定者：
      check 在类 Vector<E>中
      类型参数：
      F - 所需通道类型的装箱元素类型
      参数：
      elementType - 所需通道类型
      返回：
      相同的向量
      参见：

    • maskAll

      public final VectorMask<Integer> maskAll(boolean bit)
      返回与此向量相同种类的掩码，其中每个通道根据给定的单个布尔值设置或取消设置，该值广播到所有通道。

      此方法返回此表达式的值：species().maskAll(bit)。

      指定者：
      maskAll 在类 Vector<E>中
      参数：
      bit - 要复制的给定掩码位
      返回：
      每个通道根据给定位设置或取消设置的掩码
      参见：

    • reinterpretAsShorts

      public ShortVector reinterpretAsShorts()
      将此向量重新解释为具有相同形状和内容但是short通道类型的向量，其中通道根据小端顺序从连续字节组装而成。这是一个方便的方法，表达式为reinterpretShape(species().withLanes(short.class))。它可以被视为Vector.reinterpretAsBytes()的逆操作。
      指定者：
      reinterpretAsShorts 在类 Vector<E>中
      返回：
      具有相同形状和信息内容的ShortVector

    • reinterpretAsInts

      public IntVector reinterpretAsInts()
      将此向量重新解释为具有相同形状和内容但是int通道类型的向量，其中通道根据小端顺序从连续字节组装而成。这是一个方便的方法，表达式为reinterpretShape(species().withLanes(int.class))。它可以被视为Vector.reinterpretAsBytes()的逆操作。
      指定者：
      reinterpretAsInts 在类 Vector<E>中
      返回：
      具有相同形状和信息内容的IntVector

    • reinterpretAsLongs

      public LongVector reinterpretAsLongs()
      将此向量重新解释为相同形状和内容但是具有 long 车道类型的向量，其中车道按照小端顺序从连续字节组装而成。这是一个方便的方法，用于表达式 reinterpretShape(species().withLanes(long.class))。它可以被视为 Vector.reinterpretAsBytes() 的逆操作。
      指定者:
      reinterpretAsLongs 在类 Vector<E>
      返回:
      一个具有相同形状和信息内容的 LongVector

    • reinterpretAsFloats

      public FloatVector reinterpretAsFloats()
      将此向量重新解释为相同形状和内容但是具有 float 车道类型的向量，其中车道按照小端顺序从连续字节组装而成。这是一个方便的方法，用于表达式 reinterpretShape(species().withLanes(float.class))。它可以被视为 Vector.reinterpretAsBytes() 的逆操作。
      指定者:
      reinterpretAsFloats 在类 Vector<E>
      返回:
      一个具有相同形状和信息内容的 FloatVector

    • reinterpretAsDoubles

      public DoubleVector reinterpretAsDoubles()
      将此向量重新解释为相同形状和内容但是具有 double 车道类型的向量，其中车道按照小端顺序从连续字节组装而成。这是一个方便的方法，用于表达式 reinterpretShape(species().withLanes(double.class))。它可以被视为 Vector.reinterpretAsBytes() 的逆操作。
      指定者:
      reinterpretAsDoubles 在类 Vector<E>
      返回:
      一个具有相同形状和信息内容的 DoubleVector

    • convert

      public final <F> Vector<F> convert(VectorOperators.Conversion<Integer,F> conv, int part)
      将此向量转换为相同形状但新元素类型的向量，根据指定的 转换 将当前 ETYPE 的车道值转换为新的车道类型（这里称为 FTYPE）。这是一个逐车道形状不变的操作，它将输入向量中的 ETYPE 值复制到结果中对应的 FTYPE 值。根据所选的转换，此操作可能会 扩展或收缩 其逻辑结果，此时非零的 part 数字可以进一步控制逻辑结果的选择和将逻辑结果导入物理输出向量。

      每个具体的转换在类 VectorOperators 中由一个转换常量描述。每个转换操作符都有指定的 域类型 和 范围类型。域类型必须与输入向量的车道类型完全匹配，而范围类型确定输出向量的车道类型。

      转换操作符可以根据其域类型的位大小被分类为就地、扩展或收缩，具体取决于其范围类型的位大小是相等、小于还是大于其域类型的位大小。

      独立地，转换操作还可以根据是否转换保持表示位不变而被分类为重新解释或值转换。如果转换是重新解释的且收缩，它将截断输入的高位。如果它扩展，当没有对应的输入位时，它将用零位填充输出的高位。

      像 S2I（short 值到 int）这样的扩展转换会将标量值表示为更大的格式（始终带有一些信息冗余）。像 D2F（double 值到 float）这样的收缩转换会将标量值表示为更小的格式（始终带有一些信息丢失）。一些就地转换也可能包括信息丢失，例如 L2D（long 值到 double）或 F2I（float 值到 int）。重新解释的就地转换不会有信息丢失，除非比特值在某种程度上在输出类型中不合法。转换 NaN 的位模式可能会丢弃 NaN 的尾数位。

      这种分类很重要，因为除非另有说明，转换操作 永远不会改变向量形状，无论它们如何改变 车道大小。因此，一个 扩展 转换不能将其所有结果存储在输出向量中，因为输出向量具有更少的车道，但车道更大，以便具有与输入相同的总位大小。同样，一个 收缩 转换必须将其相对较小的结果存储到输出向量的一部分车道中，并将未使用的车道默认为零。

      例如，从 byte 转换为 long（M=8）将丢弃 87.5% 的输入值，以便将剩余的 12.5% 转换为宽敞的 long 车道的输出向量。逆转换将转换回所有大的结果，但将浪费输出向量中 87.5% 的车道。 就地 转换（M=1）将在一个输出向量中提供所有结果，而不浪费车道。

      为了管理这些 扩展和收缩 的细节，一个非零的 part 参数选择扩展的部分结果，或将收缩的结果导入相应的位置，如下所示：

      • 扩展 M： part 必须在范围 [0..M-1] 内，并选择从 原始车道 在 part*VLENGTH/M 处开始的 VLENGTH/M 输入车道块。

        VLENGTH/M 输出车道代表转换的整体逻辑结果的部分切片，填充整个物理输出向量。

      • 收缩 M： part 必须在范围 [-M+1..0] 内，并将所有 VLENGTH 输入车道导入位于 原始车道 -part*VLENGTH 处的输出。总共有 VLENGTH*M 输出车道，那些不包含转换后的输入值的车道将被填充为零。

        一组这样的输出向量，其中逻辑结果部分导入到不相交的块中，可以使用 按位或 或（对于浮点数）FIRST_NONZERO 操作符重新组装。

      • 就地（M=1）： part 必须为零。两个向量具有相同的 VLENGTH。结果始终位于零的 原始车道 处。

      此方法是更一般但不太常用的 改变形状 方法 convertShape() 的受限版本。此方法的结果与表达式 this.convertShape(conv, rsp, this.broadcast(part)) 相同，其中输出 species 为 rsp=this.species().withLanes(FTYPE.class)。

      指定者:
      convert 在类 Vector<E>
      类型参数:
      F - 物种的装箱元素类型
      参数:
      conv - 应用于每个车道的所需标量转换
      part - 结果的 部分编号，如果既不扩展也不收缩，则为零
      返回:
      通过形状和元素类型从此向量转换的向量
      参见:

    • castShape

      public final <F> Vector<F> castShape(VectorSpecies<F> toSpecies, int part)
      将一个向量从一种车道类型转换为另一种，根据需要重新塑造车道大小。此方法返回以下表达式的值：convertShape(conv,rsp,part)，其中 conv 为 VectorOperators.Conversion.ofCast(E.class,F.class)。

      如果旧物种和新物种具有不同的形状，则这是一个 改变形状 操作，可能具有特殊的实现成本。

      指定者:
      castShape 在类 Vector<E>
      类型参数:
      F - 输出物种的装箱元素类型
      参数:
      toSpecies - 所需的输出物种
      part - 结果的 部分编号，如果既不扩展也不收缩，则为零
      返回:
      通过元素类型从此向量转换的向量
      参见:

    • convertShape

      public abstract <F> Vector<F> convertShape(VectorOperators.Conversion<Integer,F> conv, VectorSpecies<F> rsp, int part)
      将此向量转换为给定种类、形状和元素类型的向量，根据指定的转换将当前ETYPE的车道值转换为新的车道类型（此处称为FTYPE）。这是一种逐车道操作，将输入向量中的ETYPE值复制到结果中对应的FTYPE值中。

      如果旧种类和新种类具有相同的形状，则行为与更简单的、形状不变的方法convert()完全相同。在这种情况下，应该使用更简单的方法convert()，以便更容易理解代码。否则，这是一种改变形状的操作，可能具有特殊的实现成本。

      由于形状变化和车道大小变化的综合效果，输入和输出种类可能具有不同的车道计数，导致扩展或收缩。在这种情况下，非零的part参数从扩展的逻辑结果中选择部分结果，或将收缩的逻辑结果的结果导入到所需输出种类的物理输出向量中。

      以下伪代码说明了此方法对于原位、扩展和收缩转换的行为。（此伪代码也适用于形状不变的方法，但对输出种类有形状限制。）请注意，对于任何特定的转换运算符和形状组合，只有三个代码路径中的一个与之相关。

      
 FTYPE scalar_conversion_op(ETYPE s);
 EVector a = ...;
 VectorSpecies<F> rsp = ...;
 int part = ...;
 VectorSpecies<E> dsp = a.species();
 int domlen = dsp.length();
 int ranlen = rsp.length();
 FTYPE[] logical = new FTYPE[domlen];
 for (int i = 0; i < domlen; i++) {
   logical[i] = scalar_conversion_op(a.lane(i));
 }
 FTYPE[] physical;
 if (domlen == ranlen) { // 原位
     assert part == 0; //否则AIOOBE
     physical = logical;
 } else if (domlen > ranlen) { // 扩展
     int M = domlen / ranlen;
     assert 0 <= part && part < M; //否则AIOOBE
     int origin = part * ranlen;
     physical = Arrays.copyOfRange(logical, origin, origin + ranlen);
 } else { // (domlen < ranlen) // 收缩
     int M = ranlen / domlen;
     assert 0 >= part && part > -M; //否则AIOOBE
     int origin = -part * domlen;
     System.arraycopy(logical, 0, physical, origin, domlen);
 }
 return FVector.fromArray(ran, physical, 0);
      指定者:
      convertShape 在类 Vector<E>
      类型参数:
      F - 输出种类的装箱元素类型
      参数:
      conv - 要应用的期望标量转换
      rsp - 期望的输出种类
      part - 结果的部分编号，如果既不扩展也不收缩，则为零
      返回值:
      通过元素类型从此向量转换的向量
      参见:

    • getPayload

      protected final Object getPayload()