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

Class ByteVector

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

  • Field Details

  • Method Details

    • zero

      public static ByteVector zero(VectorSpecies<Byte> species)
      返回给定种类的向量，其中所有通道元素均设置为零，默认原始值。
      参数:
      species - 所需零向量的种类
      返回:
      一个零向量

    • broadcast

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

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

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

    • broadcast

      public static ByteVector broadcast(VectorSpecies<Byte> species, byte e)
      返回一个给定种类的向量，其中所有车道元素都设置为原始值e。
      参数:
      species - 所需向量的种类
      e - 要广播的值
      返回:
      一个向量，其中所有车道元素都设置为原始值e
      参见:

    • broadcast

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

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

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

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

    • broadcast

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • add

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

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

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

    • add

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

    • add

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

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

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

    • add

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

    • sub

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

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

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

    • sub

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

    • sub

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

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

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

    • sub

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

    • mul

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

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

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

    • mul

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

    • mul

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

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

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

    • mul

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

    • div

      public final ByteVector div(Vector<Byte> v)
      将此向量除以第二个输入向量。这是一种车道级二进制操作，对应每对相应车道值应用原始除法操作（/）。此方法也等效于表达式lanewise(DIV, v)。

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

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

    • div

      public final ByteVector div(byte e)
      将此向量除以输入标量的广播。这是一种车道级二进制操作，对每个车道应用原始除法操作（/）。此方法也等效于表达式lanewise(DIV, e)。
      API 注意:
      如果除数为零，将抛出 ArithmeticException。
      参数:
      e - 输入标量
      返回:
      将此向量的每个车道除以标量的结果
      参见:

    • div

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

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

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

    • div

      public final ByteVector div(byte e, VectorMask<Byte> m)
      在掩码控制下，将此向量除以输入标量的广播。这是一种掩码车道级二进制操作，对每个车道应用原始除法操作（/）。此方法也等效于表达式lanewise(DIV, s, m)。
      API 注意:
      如果除数为零，将抛出 ArithmeticException。
      参数:
      e - 输入标量
      m - 控制车道选择的掩码
      返回:
      将此向量的每个车道除以标量的结果
      参见:

    • min

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

    • min

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

    • max

      public final ByteVector max(Vector<Byte> v)
      计算此向量和第二个输入向量中较大的值。这是一种逐个lane应用操作Math.max()到每对对应lane值的二元操作。此方法也等同于表达式lanewise(MAX, v)。

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

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

    • max

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

    • and

      public final ByteVector and(Vector<Byte> v)
      计算此向量和第二个输入向量的按位逻辑与（&）。这是一种逐个lane应用原始按位"与"操作（&）到每对应lane值的二元操作。此方法也等同于表达式lanewise(AND, v)。

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

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

    • and

      public final ByteVector and(byte e)
      计算此向量和标量的按位逻辑与（&）。这是一种逐个lane应用原始按位"与"操作（&）到每对应lane值的二元操作。此方法也等同于表达式lanewise(AND, e)。
      参数:
      e - 输入标量
      返回:
      此向量和标量的按位&
      参见:

    • or

      public final ByteVector or(Vector<Byte> v)
      计算此向量和第二个输入向量的按位逻辑或（|）。这是一种逐个lane应用原始按位"或"操作（|）到每对应lane值的二元操作。此方法也等同于表达式lanewise(AND, v)。

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

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

    • or

      public final ByteVector or(byte e)
      计算此向量和标量的按位逻辑或（|）。这是一种逐个lane应用原始按位"或"操作（|）到每对应lane值的二元操作。此方法也等同于表达式lanewise(OR, e)。
      参数:
      e - 输入标量
      返回:
      此向量和标量的按位|
      参见:

    • neg

      public final ByteVector neg()
      对此向量取反。这是一种逐个lane应用原始取反操作（-x）到每个输入lane的一元操作。此方法也等同于表达式lanewise(NEG)。
      指定者:
      neg 在类 Vector<Byte>
      返回:
      此向量的取反
      参见:

    • abs

      public final ByteVector abs()
      返回此向量的绝对值。这是一种逐个lane应用方法Math.abs到每个输入lane的一元操作。此方法也等同于表达式lanewise(ABS)。
      指定者:
      abs 在类 Vector<Byte>
      返回:
      此向量的绝对值
      参见:

    • not

      public final ByteVector not()
      计算此向量的按位逻辑补（~）。这是一种逐个lane应用原始按位"非"操作（~）到每个lane值的二元操作。此方法也等同于表达式lanewise(NOT)。

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

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

    • eq

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

    • eq

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

    • lt

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

    • lt

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

    • test

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

    • test

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

    • compare

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

    • compare

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

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

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

    • compare

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

    • compare

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

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

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

    • compare

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

    • blend

      public abstract ByteVector blend(Vector<Byte> v, VectorMask<Byte> m)
      使用第二个输入向量中的对应lane值替换此向量的选定lane。这是一种掩码lane-wise二进制操作，从一个输入或另一个输入中选择每个lane值。
      • 对于掩码中的任何已设置的lane，新的lane值取自第二个输入向量，并替换此向量的该lane中原有的任何值。
      • 对于掩码中的任何未设置的lane，替换被抑制，此向量保留该lane中原始值。
      以下伪代码说明了这种行为： 
      
 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<Byte>中
      参数:
      v - 第二个输入向量，包含替换lane值
      m - 控制从第二个输入向量中选择lane的掩码
      返回值:
      将此向量的lane元素与第二个输入向量的lane元素混合的结果

    • addIndex

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

      缩放必须不要太大，元素大小也不要太小，以至于在计算任何N*scale或VLENGTH*scale时会发生溢出，当使用向量lane类型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<Byte>中
      参数:
      scale - 用于将每个lane索引N乘以的数字，通常为1
      返回值:
      将每个lane元素递增其对应的lane索引N乘以scale的结果

    • blend

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

    • blend

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

    • slice

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

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

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

      参数:
      origin - 要传输到切片中的第一个输入lane
      v1 - 在切片被取出之前与第一个逻辑连接的第二个向量（如果省略，则默认为零）
      返回值:
      从指定起点开始，从此向量中取出的长度为VLENGTH的连续lane切片，并继续（如有必要）进入第二个向量
      参见:

    • slice

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

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

      指定者:
      slice 在类 Vector<Byte>中
      参数:
      origin - 要传输到切片中的第一个输入lane
      w - 在切片被取出之前与第一个逻辑连接的第二个向量（如果省略，则默认为零）
      m - 控制将lane选择到结果向量中的掩码
      返回值:
      从指定起点开始，从此向量中取出的长度为VLENGTH的连续lane切片，并继续（如有必要）进入第二个向量
      参见:

    • slice

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

    • unslice

      public abstract ByteVector unslice(int origin, Vector<Byte> 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<Byte>
      参数:
      origin - 接收切片的第一个输出车道
      w - 将接收插入切片的背景向量（作为两个副本）
      part - 结果的部分编号（零或一）
      返回:
      由插入的向量指示的背景向量对中的第一个或第二个部分
      参见:

    • unslice

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

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

      指定者:
      unslice 在类 Vector<Byte>
      参数:
      origin - 接收切片的第一个输出车道
      w - 将接收插入切片的背景向量（作为两个副本），如果它们在m中被设置
      part - 结果的部分编号（零或一）
      m - 控制从当前向量中选择车道的掩码
      返回:
      由插入的选定车道指示的背景向量对中的第一个或第二个部分
      参见:

    • unslice

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

    • rearrange

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

    • rearrange

      public abstract ByteVector rearrange(VectorShuffle<Byte> s, VectorMask<Byte> 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<Byte>
      参数:
      s - 控制车道索引选择的洗牌
      m - 控制洗牌应用的掩码
      返回:
      重新排列此向量的车道元素
      参见:

    • rearrange

      public abstract ByteVector rearrange(VectorShuffle<Byte> s, Vector<Byte> 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<Byte>
      参数：
      s - 控制从两个输入向量中选择车道的洗牌
      v - 第二个输入向量
      返回：
      该向量和第二个输入向量的车道元素的重新排列
      参见：

    • compress

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

    • expand

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

    • selectFrom

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

    • selectFrom

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

    • bitwiseBlend

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

    • bitwiseBlend

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

    • bitwiseBlend

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

    • bitwiseBlend

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

    • reduceLanes

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

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

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

    • reduceLanes

      public abstract byte reduceLanes(VectorOperators.Associative op, VectorMask<Byte> m)
      返回一个从该向量的选定通道累积的值的数组，由掩码控制。这是一个关联的跨通道归约操作，将指定的操作应用于选定的通道元素。

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

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

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

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

    • lane

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

    • withLane

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

    • toArray

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

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

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

    • toIntArray

      public final int[] toIntArray()
      返回一个包含所有通道值的int[]数组，转换为类型int。数组长度与向量长度相同。数组元素按通道顺序转换并存储。 当此操作用于ByteVector类型的向量时，不会丢失精度或范围，因此不会抛出UnsupportedOperationException。
      指定者:
      toIntArray 在类 Vector<Byte>中
      实现注意:
      当此方法用于ByteVector类型的向量时，不会丢失精度或范围，因此不会抛出UnsupportedOperationException。
      返回:
      包含此向量的通道值的int[]数组
      参见:

    • toLongArray

      public final long[] toLongArray()
      返回一个包含所有通道值的long[]数组，转换为类型long。数组长度与向量长度相同。数组元素按通道顺序转换并存储。 当此操作用于ByteVector类型的向量时，不会丢失精度或范围，因此不会抛出UnsupportedOperationException。
      指定者：
      toLongArray 在类 Vector<Byte>中
      实现注意事项：
      当在类型为ByteVector的向量上使用此方法时，不会丢失精度或范围，因此不会抛出UnsupportedOperationException。
      返回：
      包含此向量的通道值的long[]数组
      参见：

    • toDoubleArray

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

    • fromArray

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

    • fromArray

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

    • fromArray

      public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset)
      从类型为byte[]的数组中收集由固定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 ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)
      从类型为byte[]的数组中收集由掩码控制的元素组成的新向量，并使用固定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
      参见：

    • fromBooleanArray

      public static ByteVector fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset)
      从偏移处开始加载类型为boolean[]的数组的向量。对于每个向量通道，其中N是向量通道索引，将索引为offset + N的数组元素首先转换为byte值，然后放入结果向量的通道索引N处。

      将boolean值转换为byte值的方法是应用表达式(byte) (b ? 1 : 0)，其中b是boolean值。

      参数：
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量
      返回：
      从数组加载的向量
      抛出：
      IndexOutOfBoundsException - 如果对于向量中的任何通道N，offset+N < 0或offset+N >= a.length

    • fromBooleanArray

      public static ByteVector fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, VectorMask<Byte> m)
      从偏移处开始加载类型为boolean[]的数组的向量，并使用掩码。未设置掩码的通道将填充为byte的默认值（零）。对于每个向量通道，其中N是向量通道索引，如果掩码通道索引N已设置，则将索引为offset + N的数组元素首先转换为byte值，然后放入结果向量的通道索引N处，否则将默认元素值放入结果向量的通道索引N处。

      将boolean值转换为byte值的方法是应用表达式(byte) (b ? 1 : 0)，其中b是boolean值。

      参数：
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量
      m - 控制通道选择的掩码
      返回：
      从数组加载的向量
      抛出：
      IndexOutOfBoundsException - 如果对于向量中的任何通道N，offset+N < 0或offset+N >= a.length

    • fromBooleanArray

      public static ByteVector fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset)
      从类型为boolean[]的数组中收集由固定offset和从索引映射的次要偏移系列中添加的索引组成的新向量。索引映射是第二个int数组中从给定mapOffset开始的连续VLENGTH元素序列。

      对于每个向量通道，其中N是向量通道索引，通道从表达式(byte) (a[f(N)] ? 1 : 0)加载，其中f(N)是索引映射表达式offset + indexMap[mapOffset + N]]。

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

    • fromBooleanArray

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

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

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

    • fromMemorySegment

      public static ByteVector fromMemorySegment(VectorSpecies<Byte> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)
      从内存段的偏移量开始加载向量memory segmentPREVIEW。字节根据指定的字节顺序组成原始通道元素。向量根据内存排序排列。

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

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

    • fromMemorySegment

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

      以下伪代码说明了行为：

      
 var slice = ms.asSlice(offset);
 byte[] ar = new byte[species.length()];
 for (int n = 0; n < ar.length; n++) {
     if (m.laneIsSet(n)) {
         ar[n] = slice.getAtIndex(ValuaLayout.JAVA_BYTE.withByteAlignment(1), n);
     }
 }
 ByteVector r = ByteVector.fromArray(species, ar, 0);
      实现注意:
      忽略字节顺序参数
      参数:
      species - 所需向量的种类
      ms - 内存段
      offset - 内存段中的偏移量
      bo - 预期的字节顺序
      m - 控制通道存储的掩码
      返回:
      从内存段加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于向量中的任何通道N，offset+N*1 < 0或offset+N*1 >= ms.byteSize()且掩码已设置
      IllegalArgumentException - 如果内存段是不由byte[]数组支持的堆段
      IllegalStateException - 如果内存段的会话未激活，或者从不拥有会话的线程以外的线程访问
      自:
      19

    • intoArray

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

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

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

    • intoArray

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

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

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

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

    • intoArray

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

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

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

    • intoArray

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

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

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

    • intoBooleanArray

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

      对于每个向量通道，其中N是向量通道索引，索引为N的通道元素首先转换为boolean值，然后存储到数组元素a[offset+N]中。

      byte值通过应用表达式(b & 1) != 0转换为boolean值，其中b是byte值。

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

    • intoBooleanArray

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

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

      byte值通过应用表达式(b & 1) != 0转换为boolean值，其中b是byte值。

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

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

    • intoBooleanArray

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

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

      byte值通过应用表达式(b & 1) != 0转换为boolean值，其中b是byte值。

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

    • intoBooleanArray

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

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

      byte值通过应用表达式(b & 1) != 0转换为boolean值，其中b是byte值。

      参数:
      a - 数组
      offset - 与索引映射偏移量相结合的偏移量
      indexMap - 索引映射
      mapOffset - 索引映射的偏移量
      m - 掩码
      抛出:
      IndexOutOfBoundsException - 如果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)
      将此向量视为具有相同形状和内容但通道类型为byte的向量，其中字节根据小端序从通道中提取。这是一个方便的方法，用于表达式reinterpretShape(species().withLanes(byte.class))。它可以被认为是将字节合并到同一向量中的更大通道的各种方法的逆操作，例如Vector.reinterpretAsInts()。
      Specified by:
      intoMemorySegment in class Vector<Byte>
      Parameters:
      ms - the memory segment
      offset - the offset into the memory segment
      bo - the intended byte order
      Since:
      19

    • intoMemorySegment

      public final void intoMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Byte> m)
      Stores this vector into a memory segmentPREVIEW starting at an offset using explicit byte order and a mask.

      Bytes are extracted from primitive lane elements according to the specified byte ordering. The lanes are stored according to their memory ordering.

      The following pseudocode illustrates the behavior, where JAVA_E is the layout of the primitive element type, ETYPE is the primitive element type, and EVector is the primitive vector type for this vector:

      
 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);
     }
 }
      Specified by:
      intoMemorySegment in class Vector<Byte>
      Parameters:
      ms - the memory segment
      offset - the offset into the memory segment
      bo - the intended byte order
      m - the mask controlling lane selection
      Since:
      19

    • reinterpretAsBytes

      public final ByteVector reinterpretAsBytes()
      Views this vector as a vector of the same shape and contents but a lane type of byte, where the bytes are extracted from the lanes according to little-endian order. It is a convenience method for the expression reinterpretShape(species().withLanes(byte.class)). It may be considered an inverse to the various methods which consolidate bytes into larger lanes within the same vector, such as Vector.reinterpretAsInts().
      指定者:
      reinterpretAsBytes 在类 Vector<Byte>中
      返回值:
      一个具有相同形状和信息内容的ByteVector
      参见:

    • viewAsIntegralLanes

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

    • viewAsFloatingLanes

      public final Vector<?> viewAsFloatingLanes()
      将此向量视为具有相同形状、长度和内容的向量，但是车道类型是浮点类型。这是对车道值进行的逐车道重新解释转换。因此，此方法不会更改VSHAPE或VLENGTH，向量的位内容也不会更改。如果向量的ETYPE已经是浮点类型，则返回相同的向量。如果向量的元素大小与任何浮点类型大小不匹配，则会抛出IllegalArgumentException。此方法返回此表达式的值：convert(conv,0)，其中conv是VectorOperators.Conversion.ofReinterpret(E.class,F.class)，F是与E大小相同的浮点类型，如果有的话。
      指定者:
      viewAsFloatingLanes 在类 Vector<Byte>中
      实现注意:
      此方法始终抛出UnsupportedOperationException，因为没有与byte大小相同的浮点类型。此方法的返回类型被任意指定为Vector<?>。如果将来的API版本中提供了其他浮点类型，则可能会更改返回类型。
      返回值:
      将原始向量重新解释为浮点数
      参见:

    • toString

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

    • equals

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

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

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

    • hashCode

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

    • species

      public final VectorSpecies<Byte> 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<Byte> 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<Byte,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]内，并选择从原始通道开始的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<Byte,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) { // 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 - 应用于每个车道的期望标量转换
      rsp - 所需的输出物种
      part - 结果的部分编号，如果既不扩展也不收缩，则为零
      返回：
      通过元素类型从此向量转换的向量
      参见：

    • getPayload

      protected final Object getPayload()