模块 jdk.incubator.vector
包 jdk.incubator.vector

类 IntVector

java.lang.Object
jdk.incubator.vector.Vector <E>
jdk.incubator.vector.IntVector
public abstract class IntVector extends Vector <E>
IntVector 依赖于 Java 平台的预览功能：
程序只能在启用预览功能时使用 IntVector。
预览功能可能会在未来的版本中删除，或升级为 Java 平台的永久功能。
一个专门的 Vector 表示 int 值的有序不可变序列。

  • 字段详细信息

  • 方法详情

    • zero

      public static IntVector  zero(VectorSpecies <Integer > species)
      返回给定物种的向量，其中所有车道元素都设置为零，即默认原始值。
      参数：
      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)
      返回一个与这个相同种类的向量，其中所有车道元素都设置为原始值 e 。当前向量的内容被丢弃；只有物种与此操作相关。

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

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

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

    • broadcast

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

      public final IntVector  lanewise(VectorOperators.Binary  op, long e)
      将此向量的车道值与广播标量的值相结合。这是一个 lane-wise 二元操作，它将选择的操作应用到每个 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)
      将此向量的相应车道值与第二个输入向量的车道值相结合，并选择由掩码控制的车道元素。这是一个 lane-wise 二元操作，它将选择的操作应用到每个 lane。第二个操作数是一个广播整数值。返回值将等于此表达式：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)
      将此向量的相应车道值与第二个和第三个输入向量的车道组合。这是一个 lane-wise 三元运算，它将选定的运算应用于每个通道。
      指定者：
      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()
      否定这个向量。这是一个 lane-wise 一元操作，它将原语否定操作 (-x) 应用于每个输入通道。此方法也等效于表达式 lanewise ( NEG ) 。
      指定者：
      neg 在类 Vector<Integer> 中
      返回：
      这个向量的否定
      参见：

    • abs

      public final IntVector  abs()
      返回此向量的绝对值。这是一个 lane-wise 一元操作，它将方法 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)
      在掩码的控制下，用来自第二个输入向量的相应车道替换此向量的选定车道。这是一种屏蔽的车道二元运算，它从一个或另一个输入中选择每个车道值。
      • 对于掩码中的任何车道 set，新的车道值取自第二个输入向量，并替换该向量的该车道中的任何值。
      • 对于掩码中的任何通道 unset，替换被抑制并且该向量保留存储在该通道中的原始值。
      以下伪代码说明了此行为： 
      
 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 中已有的值。

      规模不能太大，元素大小不能太小，以至于在计算任何 N*scale 或 VLENGTH*scale 时会出现溢出，当结果使用向量通道类型 ETYPE 表示时。

      以下伪代码说明了此行为：

      
 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 - 结果的部分编号（零或一）
      返回：
      一对背景向量 w 的第一部分或第二部分，通过在指定原点插入该向量进行更新
      参见：

    • 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 - 从当前向量中控制车道选择的掩码
      返回：
      一对背景向量 w 的第一部分或第二部分，通过在指定原点插入该向量的选定通道进行更新
      参见：

    • 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)，输出通道N从通道I如果I>=0的第一个向量获得值。否则，异常索引 I 通过向其添加 VLENGTH 进行包装，并用于在索引 I+VLENGTH 处索引 second 向量。

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

      
 Vector<E> r1 = this.rearrange(s.wrapIndexes());
 // or else: 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 - 控制压缩的掩码
      返回：
      此向量的压缩车道元素
      自从：
      19

    • expand

      public abstract IntVector  expand(VectorMask <Integer > m)
      在特定掩码的控制下扩展此矢量的车道元素。这是一个跨车道操作，它将此向量的连续车道元素扩展到由指定掩码选择的输出向量的车道中。对于掩码的每个通道 N，如果设置了通道 N 处的掩码，则选择从通道 0 开始的输入向量的下一个连续元素，并将其存储到通道 N 的输出向量中。输出向量的所有剩余通道（如果有的话）都设置为零。
      指定者：
      expand 在类 Vector<Integer> 中
      参数：
      m - 控制压缩的掩码
      返回：
      此向量的扩展车道元素
      自从：
      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)
      在提供掩码位的标量控制下将两个向量的位混合在一起。这是一个车道三元运算，它对每个车道执行按位混合操作(a&~c)|(b&c)。此方法也等效于表达式 lanewise ( BITWISE_BLEND , bits, mask) 。
      参数：
      bits - 要混合到当前向量中的输入位
      mask - 启用输入位混合的按位掩码
      返回：
      在按位掩码的控制下，将给定位按位混合到当前向量中
      参见：

    • reduceLanes

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

      一些归约操作不支持对其操作数进行任意重新排序，但由于它们的实用性而被包含在这里。

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

    • reduceLanes

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

      如果未选择任何元素，则返回特定于操作的标识值。

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

      一些归约操作不支持对其操作数进行任意重新排序，但由于它们的实用性而被包含在这里。

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

    • lane

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

    • withLane

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

    • toArray

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

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

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

    • toIntArray

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

    • toLongArray

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

    • toDoubleArray

      public final double[] toDoubleArray()
      返回包含所有车道值的 double[] 数组，转换为类型 double 。数组长度与向量长度相同。数组元素的转换就像通过强制转换一样，并按通道顺序存储。如果向量元素类型为 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 - 如果 offset+N < 0 或 offset+N >= a.length 用于向量中的任何通道 N

    • fromArray

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

    • fromArray

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

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

      参数：
      species - 所需载体的种类
      a - 阵列
      offset - 数组中的偏移量，如果索引map中的相对索引补偿以产生数组边界内的值，则可能为负
      indexMap - 索引图
      mapOffset - 索引map中的偏移量
      返回：
      从数组的索引元素加载的向量
      抛出：
      IndexOutOfBoundsException - 如果 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 添加到来自 index map 的一系列辅助偏移量而获得的索引。索引映射是第二个 int 数组中 VLENGTH 元素的连续序列，从给定的 mapOffset 开始。

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

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

    • fromMemorySegment

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

      此方法的行为就好像它返回调用 fromMemorySegment() 的结果一样PREVIEW 如下：

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

    • fromMemorySegment

      public static IntVector  fromMemorySegment(VectorSpecies <Integer > species, MemorySegment PREVIEW  ms, long offset, ByteOrder  bo, VectorMask <Integer > m)
      从 内存段 加载一个向量PREVIEW 从内存段的偏移量开始并使用掩码。未设置掩码的通道用默认值 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.withBitAlignment(8), n);
   }
 }
 IntVector r = IntVector.fromArray(species, ar, 0);
      实现注意事项：
      如果指定的字节顺序与 平台原生订单 相同，此操作可能会更有效，因为此方法不需要重新排序通道值的字节。
      参数：
      species - 所需载体的种类
      ms - 内存段
      offset - 内存段的偏移量
      bo - 预期的字节顺序
      m - 掩码控制车道选择
      返回：
      从内存段加载的向量
      抛出：
      IndexOutOfBoundsException - 如果 offset+N*4 < 0 或 offset+N*4 >= ms.byteSize() 用于设置掩码的向量中的任何通道 N
      IllegalArgumentException - 如果内存段是堆段且不受 byte[] 数组支持。
      IllegalStateException - 如果内存段的会话不活动，或者访问发生在线程拥有会话以外的线程。
      自从：
      19

    • intoArray

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

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

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

    • 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 - 如果 offset+N < 0 或 offset+N >= a.length 用于设置掩码的向量中的任何通道 N

    • intoArray

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

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

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

    • intoArray

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

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

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

    • intoMemorySegment

      public final void intoMemorySegment(MemorySegment PREVIEW  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(MemorySegment PREVIEW  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)
      返回与此向量相同物种的掩码，其中根据给定的单个boolean设置或取消设置每个车道，该boolean广播到所有车道。

      此方法返回此表达式的值：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 的有效数字中的位。

      这种分类很重要，因为除非另有说明，否则转换操作 never change vector shape ，无论它们如何更改 lane sizes 。因此，expanding 转换不能将其所有结果存储在其输出向量中，因为输出向量具有较少的较大尺寸的通道，以便具有与其输入相同的总体位大小。同样，收缩转换必须将其相对较小的结果存储到输出向量通道的子集中，将未使用的通道默认为零。

      例如，从 byte 到 long (M=8 ) 的转换将丢弃 87.5% 的输入值，以便将剩余的 12.5% 转换为输出向量的宽敞 long 通道。反向转换将转换回所有较大的结果，但会浪费输出向量中 87.5% 的通道。 In-place 转换 (M=1 ) 在一个输出向量中提供所有结果，而不会浪费通道。

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

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

        VLENGTH/M 输出通道表示转换的整个逻辑结果的部分片段，填充整个物理输出向量。

      • 由 M 收缩：part 必须在 [-M+1..0] 范围内，并将所有 VLENGTH 输入通道引导到位于 origin lane -part*VLENGTH 的输出。总共有 VLENGTH*M 个输出通道，那些没有保存转换输入值的通道用零填充。

        一组这样的输出向量，逻辑结果部分被引导到不相交的块，可以使用 按位或 或（对于浮点） FIRST_NONZERO 运算符重新组合。

      • 就地 (M=1)：part 必须为零。两个向量具有相同的 VLENGTH 。结果始终位于零的origin lane。

      此方法是更通用但不太常用的 shape-changing 方法 convertShape() 的受限版本。此方法的结果与表达式 this.convertShape(conv, rsp, this.broadcast(part)) 相同，其中输出物种为 rsp=this.species().withLanes(FTYPE.class) 。

      指定者：
      convert 在类 Vector<E> 中
      类型参数：
      F - 物种的盒装元素类型
      参数：
      conv - 应用 lane-wise 所需的标量转换
      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)。

      如果新旧物种的形状不同，这是一个 shape-changing 操作，可能有特殊的实施成本。

      指定者：
      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）。这是一个 lane-wise 操作，它将输入向量中的 ETYPE 个值复制到结果中相应的 FTYPE 个值。

      如果新旧物种具有相同的形状，则其行为与更简单的形状不变方法 convert() 完全相同。在这种情况下，应该使用更简单的方法 convert()，以使代码更易于推理。否则，这是一个 shape-changing 操作，可能有特殊的实施成本。

      作为形状变化和车道大小变化的综合影响，输入和输出物种可能具有不同的车道数，从而导致 扩张或收缩 。在这种情况下，非零 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) { // in-place
   assert part == 0; //else AIOOBE
   physical = logical;
 } else if (domlen > ranlen) { // expanding
   int M = domlen / ranlen;
   assert 0 <= part && part < M; //else AIOOBE
   int origin = part * ranlen;
   physical = Arrays.copyOfRange(logical, origin, origin + ranlen);
 } else { // (domlen < ranlen) // contracting
   int M = ranlen / domlen;
   assert 0 >= part && part > -M; //else AIOOBE
   int origin = -part * domlen;
   System.arraycopy(logical, 0, physical, origin, domlen);
 }
 return FVector.fromArray(ran, physical, 0);
      指定者：
      convertShape 在类 Vector<E> 中
      类型参数：
      F - 输出物种的盒装元素类型
      参数：
      conv - 应用 lane-wise 所需的标量转换
      rsp - 所需的输出种类
      part - 结果的 零件号，如果既不扩展也不收缩则为零
      返回：
      从此向量按元素类型转换的向量
      参见：

    • getPayload

      protected final Object  getPayload()