Module java.base
Package java.lang

Class Long

java.lang.Object
java.lang.Number
java.lang.Long
所有已实现的接口:
Serializable, Comparable<Long>, Constable, ConstantDesc
public final class Long extends Number implements Comparable<Long>, Constable, ConstantDesc
Long类将基本类型long的值包装在对象中。类型为Long的对象包含一个字段，其类型为long。

此外，该类提供了几种方法，用于将long转换为String，将String转换为long，以及在处理long时有用的其他常量和方法。

这是一个基于值的类；程序员应将相等的实例视为可互换的，并且不应将实例用于同步，否则可能会发生不可预测的行为。例如，在将来的版本中，同步可能会失败。

实现说明: “位操作”方法（例如highestOneBit和numberOfTrailingZeros）的实现基于Henry S. Warren, Jr.的《Hacker's Delight》（Addison Wesley, 2002）中的材料。

自版本:
1.0
另请参阅:

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final int
    BYTES
    用于以二进制补码形式表示long值所需的字节数。
    static final long
    MAX_VALUE
    一个常量，表示long可以具有的最大值，即263-1。
    static final long
    MIN_VALUE
    一个常量，表示long可以具有的最小值，即-263。
    static final int
    SIZE
    用于以二进制补码形式表示long值所需的位数。
    static final Class<Long>
    TYPE
    表示基本类型long的Class实例。

  • Constructor Summary

    Constructors
    Constructor
    Description
    Long(long value)
    已弃用，将来会移除: 此API元素可能会在将来的版本中被移除。
    很少适合使用此构造函数。
    Long(String s)
    已弃用，将来会移除: 此API元素可能会在将来的版本中被移除。
    很少适合使用此构造函数。

  • Method Summary

    Modifier and Type
    Method
    Description
    static int
    bitCount(long i)
    返回指定long值的二进制补码表示中的一位比特数。
    byte
    byteValue()
    在缩小的原始转换后，返回此Long的值作为byte。
    static int
    compare(long x, long y)
    按数字比较两个long值。
    int
    compareTo(Long anotherLong)
    按数字比较两个Long对象。
    static int
    compareUnsigned(long x, long y)
    按无符号值将两个long值作为数字进行比较。
    static long
    compress(long i, long mask)
    根据指定的位掩码，返回压缩指定long值i的位的值。
    static Long
    decode(String nm)
    将String解码为Long。
    Optional<Long>
    describeConstable()
    返回包含此实例的名义描述符的Optional，即实例本身。
    static long
    divideUnsigned(long dividend, long divisor)
    返回将第一个参数除以第二个参数的无符号商，其中每个参数和结果都被解释为无符号值。
    double
    doubleValue()
    在扩展的原始转换后，返回此Long的值作为double。
    boolean
    equals(Object obj)
    将此对象与指定对象进行比较。
    static long
    expand(long i, long mask)
    根据指定的位掩码，返回扩展指定long值i的位的值。
    float
    floatValue()
    在扩展的原始转换后，返回此Long的值作为float。
    static Long
    getLong(String nm)
    确定具有指定名称的系统属性的long值。
    static Long
    getLong(String nm, long val)
    确定具有指定名称的系统属性的long值。
    static Long
    getLong(String nm, Long val)
    返回具有指定名称的系统属性的long值。
    int
    hashCode()
    返回此Long的哈希码。
    static int
    hashCode(long value)
    返回long值的哈希码；与Long.hashCode()兼容。
    static long
    highestOneBit(long i)
    返回具有指定long值中最高位（“最左侧”）的一个位的long值。
    int
    intValue()
    在缩小的原始转换后，返回此Long的值作为int。
    long
    longValue()
    返回此Long的值作为long值。
    static long
    lowestOneBit(long i)
    返回具有指定long值中最低位（“最右侧”）的一个位的long值。
    static long
    max(long a, long b)
    返回两个long值中较大的值，如通过调用Math.max。
    static long
    min(long a, long b)
    返回两个long值中较小的值，如通过调用Math.min。
    static int
    numberOfLeadingZeros(long i)
    返回指定long值的二进制补码表示中最高位（“最左侧”）之前的零位数。
    static int
    numberOfTrailingZeros(long i)
    返回指定long值的二进制补码表示中最低位（“最右侧”）之后的零位数。
    static long
    parseLong(CharSequence s, int beginIndex, int endIndex, int radix)
    将CharSequence参数解析为指定radix中的有符号long，从指定的beginIndex开始，延伸到endIndex - 1。
    static long
    parseLong(String s)
    将字符串参数解析为有符号的十进制long。
    static long
    parseLong(String s, int radix)
    将字符串参数解析为由第二个参数指定的基数中的有符号long。
    static long
    parseUnsignedLong(CharSequence s, int beginIndex, int endIndex, int radix)
    将CharSequence参数解析为指定radix中的无符号long，从指定的beginIndex开始，延伸到endIndex - 1。
    static long
    parseUnsignedLong(String s)
    将字符串参数解析为无符号的十进制long。
    static long
    parseUnsignedLong(String s, int radix)
    将字符串参数解析为由第二个参数指定的基数中的无符号long。
    static long
    remainderUnsigned(long dividend, long divisor)
    返回将第一个参数除以第二个参数的无符号余数，其中每个参数和结果都被解释为无符号值。
    Long
    resolveConstantDesc(MethodHandles.Lookup lookup)
    将此实例解析为ConstantDesc，其结果是实例本身。
    static long
    reverse(long i)
    返回指定long值的二进制补码表示中位的顺序颠倒后的值。
    static long
    reverseBytes(long i)
    返回指定long值的二进制补码表示中字节的顺序颠倒后的值。
    static long
    rotateLeft(long i, int distance)
    将指定long值的二进制补码表示向左旋转指定位数的值。
    static long
    rotateRight(long i, int distance)
    将指定long值的二进制补码表示向右旋转指定位数的值。
    short
    shortValue()
    在缩小的原始转换后，返回此Long的值作为short。
    static int
    signum(long i)
    返回指定long值的符号函数。
    static long
    sum(long a, long b)
    将两个long值相加，如+运算符所示。
    static String
    toBinaryString(long i)
    返回long参数的字符串表示作为二进制中的无符号整数。
    static String
    toHexString(long i)
    返回long参数的字符串表示作为十六进制中的无符号整数。
    static String
    toOctalString(long i)
    返回long参数的字符串表示作为八进制中的无符号整数。
    String
    toString()
    返回表示此Long值的String对象。
    static String
    toString(long i)
    返回表示指定long的String对象。
    static String
    toString(long i, int radix)
    返回第一个参数的字符串表示，基数由第二个参数指定。
    static String
    toUnsignedString(long i)
    返回参数的字符串表示作为无符号十进制值。
    static String
    toUnsignedString(long i, int radix)
    返回第一个参数的字符串表示作为由第二个参数指定的基数中的无符号整数值。
    static Long
    valueOf(long l)
    返回表示指定long值的Long实例。
    static Long
    valueOf(String s)
    返回包含指定String值的Long对象。
    static Long
    valueOf(String s, int radix)
    返回包含使用第二个参数给定的基数解析的指定String中提取的值的Long对象。

    Methods declared in class java.lang.Object

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait

  • Field Details

    • MIN_VALUE

      @Native public static final long MIN_VALUE
      一个常量，表示long可以具有的最小值，即-263。
      另请参阅:

    • MAX_VALUE

      @Native public static final long MAX_VALUE
      一个常量，表示long可以具有的最大值，即263-1。
      另请参阅:

    • TYPE

      public static final Class<Long> TYPE
      表示基本类型long的Class实例。
      自版本:
      1.1

    • SIZE

      @Native public static final int SIZE
      用于以二进制补码形式表示long值所需的位数。
      自版本:
      1.5
      另请参阅:

    • BYTES

      public static final int BYTES
      用于以二进制补码形式表示long值所需的字节数。
      自：
      1.8
      另请参见：

  • Constructor Details

    • Long

      @Deprecated(since="9", forRemoval=true) public Long(long value)
      Deprecated, for removal: This API element is subject to removal in a future version.
      It is rarely appropriate to use this constructor. The static factory valueOf(long) is generally a better choice, as it is likely to yield significantly better space and time performance.
      构造一个新分配的Long对象，该对象表示指定的long参数。
      参数：
      value - 要由Long对象表示的值。

    • Long

      @Deprecated(since="9", forRemoval=true) public Long(String s) throws NumberFormatException
      Deprecated, for removal: This API element is subject to removal in a future version.
      It is rarely appropriate to use this constructor. Use parseLong(String) to convert a string to a long primitive, or use valueOf(String) to convert a string to a Long object.
      构造一个新分配的Long对象，该对象表示由String参数指示的long值。该字符串以与parseLong方法在基数10下使用的方式完全相同的方式转换为long值。
      参数：
      s - 要转换为Long的String。
      抛出：
      NumberFormatException - 如果String不包含可解析的long。

  • Method Details

    • toString

      public static String toString(long i, int radix)
      返回第一个参数在由第二个参数指定的基数中的字符串表示形式。

      如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX，则使用基数10代替。

      如果第一个参数为负，则结果的第一个元素是ASCII减号符号'-'（'\u002d'）。如果第一个参数不为负，则结果中不会出现符号字符。

      结果的其余字符表示第一个参数的大小。如果大小为零，则由单个零字符'0'（'\u0030'）表示；否则，大小表示的第一个字符将不是零字符。以下ASCII字符用作数字：

      0123456789abcdefghijklmnopqrstuvwxyz
      这些是'\u0030'到'\u0039'和'\u0061'到'\u007a'。如果radix为N，则这些字符的前N个将按照所示的顺序用作基数-N数字。因此，十六进制（基数16）的数字为0123456789abcdef。如果需要大写字母，则可以在结果上调用String.toUpperCase()方法：
      Long.toString(n, 16).toUpperCase()
      参数：
      i - 要转换为字符串的long。
      radix - 在字符串表示中使用的基数。
      返回：
      参数在指定基数中的字符串表示。
      另请参见：

    • toUnsignedString

      public static String toUnsignedString(long i, int radix)
      返回第一个参数作为无符号整数值在由第二个参数指定的基数中的字符串表示形式。

      如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX，则使用基数10代替。

      请注意，由于第一个参数被视为无符号值，因此不会打印前导符号字符。

      如果大小为零，则由单个零字符'0'（'\u0030'）表示；否则，大小表示的第一个字符将不是零字符。

      基数和用作数字的字符的行为与toString相同。

      参数：
      i - 要转换为无符号字符串的整数。
      radix - 在字符串表示中使用的基数。
      返回：
      参数在指定基数中的无符号字符串表示。
      自：
      1.8
      另请参见：

    • toHexString

      public static String toHexString(long i)
      返回第一个参数作为十六进制中的无符号整数值的字符串表示形式。

      如果参数为负，则无符号long值为参数加上2的64次方；否则，它等于参数。此值转换为十六进制（基数16）的ASCII数字字符串，没有额外的前导0。

      可以通过调用Long.parseUnsignedLong(s, 16)从返回的字符串s中恢复参数的值。

      如果无符号大小为零，则由单个零字符'0'（'\u0030'）表示；否则，无符号大小的表示的第一个字符将不是零字符。以下字符用作十六进制数字：

      0123456789abcdef
      这些是字符'\u0030'到'\u0039'和'\u0061'到'\u0066'。如果需要大写字母，则可以在结果上调用String.toUpperCase()方法：
      Long.toHexString(n).toUpperCase()
      API注释：
      HexFormat类提供了对字节数组和基本类型进行格式化和解析以返回字符串或添加到Appendable的支持。 HexFormat格式化和解析大写或小写十六进制字符，包括对于每个字节的分隔符、前缀和后缀。
      参数：
      i - 要转换为字符串的long。
      返回：
      参数在十六进制（基数16）中表示的无符号long值的字符串表示。
      自：
      1.0.2
      另请参见：

    • toOctalString

      public static String toOctalString(long i)
      返回第一个参数作为八进制中的无符号整数值的字符串表示形式。

      如果参数为负，则无符号long值为参数加上2的64次方；否则，它等于参数。此值转换为八进制（基数8）的ASCII数字字符串，没有额外的前导0。

      可以通过调用Long.parseUnsignedLong(s, 8)从返回的字符串s中恢复参数的值。

      如果无符号大小为零，则由单个零字符'0'（'\u0030'）表示；否则，无符号大小的表示的第一个字符将不是零字符。以下字符用作八进制数字：

      01234567
      这些是字符'\u0030'到'\u0037'。
      参数：
      i - 要转换为字符串的long。
      返回：
      参数在八进制（基数8）中表示的无符号long值的字符串表示。
      自：
      1.0.2
      另请参见：

    • toBinaryString

      public static String toBinaryString(long i)
      返回第一个参数作为二进制中的无符号整数值的字符串表示形式。

      如果参数为负，则无符号long值为参数加上2的64次方；否则，它等于参数。此值转换为二进制（基数2）的ASCII数字字符串，没有额外的前导0。

      可以通过调用Long.parseUnsignedLong(s, 2)从返回的字符串s中恢复参数的值。

      如果无符号大小为零，则由单个零字符'0'（'\u0030'）表示；否则，无符号大小的表示的第一个字符将不是零字符。字符'0'（'\u0030')和 '1'（'\u0031')用作二进制数字。

      参数：
      i - 要转换为字符串的long。
      返回：
      参数在二进制（基数2）中表示的无符号long值的字符串表示。
      自：
      1.0.2
      另请参见：

    • toString

      public static String toString(long i)
      返回表示指定long的String对象。参数被转换为有符号十进制表示形式，并作为字符串返回，就好像参数和基数10作为参数传递给toString(long, int)方法一样。
      参数：
      i - 要转换的long。
      返回：
      参数的十进制（基数10）的字符串表示。

    • toUnsignedString

      public static String toUnsignedString(long i)
      返回参数作为无符号十进制值的字符串表示。参数被转换为无符号十进制表示形式，并作为字符串返回，就好像参数和基数10作为参数传递给toUnsignedString(long, int)方法一样。
      参数：
      i - 要转换为无符号字符串的整数。
      返回：
      参数的无符号字符串表示。
      自：
      1.8
      另请参见：

    • parseLong

      public static long parseLong(String s, int radix) throws NumberFormatException
      解析第二个参数指定的基数中的字符串参数作为有符号的long。字符串中的字符必须都是指定基数的数字（由Character.digit(char, int)返回非负值确定），除非第一个字符是ASCII减号'-'（'\u002D'）表示负值或ASCII加号'+'（'\u002B'）表示正值。返回结果long值。

      请注意，字符串末尾不允许出现字符L（'\u004C'）或l（'\u006C'）作为类型指示符，这在Java编程语言源代码中是允许的 - 但是如果基数大于或等于22，则L或l可以作为数字出现。

      如果出现以下任何情况，则会抛出NumberFormatException异常：

      • 第一个参数为null或长度为零的字符串。
      • radix小于Character.MIN_RADIX或大于Character.MAX_RADIX。
      • 字符串中的任何字符不是指定基数的数字，除非第一个字符是减号'-'（'\u002d'）或加号'+'（'\u002B'），并且字符串长度大于1。
      • 字符串表示的值不是long类型的值。

      示例：

       parseLong("0", 10) 返回 0L
 parseLong("473", 10) 返回 473L
 parseLong("+42", 10) 返回 42L
 parseLong("-0", 10) 返回 0L
 parseLong("-FF", 16) 返回 -255L
 parseLong("1100110", 2) 返回 102L
 parseLong("99", 8) 抛出NumberFormatException
 parseLong("Hazelnut", 10) 抛出NumberFormatException
 parseLong("Hazelnut", 36) 返回 1356099454469L
      参数：
      s - 包含要解析的long表示的String。
      radix - 解析s时要使用的基数。
      返回：
      在指定基数中表示的字符串参数的long。
      抛出：
      NumberFormatException - 如果字符串不包含可解析的long。

    • parseLong

      public static long parseLong(CharSequence s, int beginIndex, int endIndex, int radix) throws NumberFormatException
      将指定的radix中的CharSequence参数解析为指定radix中的有符号long，从指定的beginIndex开始，一直到endIndex - 1。

      该方法不会防止在解析过程中对CharSequence进行更改。

      参数：
      s - 包含要解析的long表示的CharSequence。
      beginIndex - 起始索引（包括）。
      endIndex - 结束索引（不包括）。
      radix - 解析s时要使用的基数。
      返回：
      在指定基数中表示的子序列的有符号long。
      抛出：
      NullPointerException - 如果s为null。
      IndexOutOfBoundsException - 如果beginIndex为负数，或者beginIndex大于endIndex，或者endIndex大于s.length()。
      NumberFormatException - 如果CharSequence不包含指定radix中可解析的long，或者radix小于Character.MIN_RADIX或大于Character.MAX_RADIX。
      自：
      9

    • parseLong

      public static long parseLong(String s) throws NumberFormatException
      将字符串参数解析为有符号的十进制long。字符串中的字符必须都是十进制数字，除非第一个字符是ASCII减号'-'（\u002D'）表示负值或ASCII加号'+'（'\u002B'）表示正值。返回结果long值，就像将参数和基数10作为参数传递给parseLong(java.lang.String, int)方法一样。

      请注意，字符串末尾不允许出现字符L（'\u004C'）或l（'\u006C'）作为类型指示符，这在Java编程语言源代码中是允许的。

      参数：
      s - 包含要解析的long表示的String。
      返回：
      十进制中表示的参数的long。
      抛出：
      NumberFormatException - 如果字符串不包含可解析的long。

    • parseUnsignedLong

      public static long parseUnsignedLong(String s, int radix) throws NumberFormatException
      将字符串参数解析为指定的基数中的无符号long。无符号整数将通常与负数相关联的值映射为大于MAX_VALUE的正数。字符串中的字符必须都是指定基数的数字（由Character.digit(char, int)返回非负值），除非第一个字符是ASCII加号'+'（'\u002B'）。返回结果整数值。

      如果出现以下任何情况，则会抛出NumberFormatException异常：

      • 第一个参数为null或长度为零的字符串。
      • 基数小于Character.MIN_RADIX或大于Character.MAX_RADIX。
      • 字符串中的任何字符不是指定基数的数字，除非第一个字符是加号'+'（'\u002B'），并且字符串长度大于1。
      • 字符串表示的值大于最大无符号long，264-1。
      参数：
      s - 包含要解析的无符号整数表示的String。
      radix - 解析s时要使用的基数。
      返回：
      在指定基数中表示的字符串参数的无符号long。
      抛出：
      NumberFormatException - 如果String不包含可解析的long。
      自：
      1.8

    • parseUnsignedLong

      public static long parseUnsignedLong(CharSequence s, int beginIndex, int endIndex, int radix) throws NumberFormatException
      将指定的radix中的CharSequence参数解析为指定radix中的无符号long，从指定的beginIndex开始，一直到endIndex - 1。

      该方法不会防止在解析过程中对CharSequence进行更改。

      参数：
      s - 包含要解析的无符号long表示的CharSequence。
      beginIndex - 起始索引（包括）。
      endIndex - 结束索引（不包括）。
      radix - 解析s时要使用的基数。
      返回：
      在指定基数中表示的子序列的无符号long。
      抛出：
      NullPointerException - 如果s为null。
      IndexOutOfBoundsException - 如果beginIndex为负数，或者beginIndex大于endIndex，或者endIndex大于s.length()。
      NumberFormatException - 如果CharSequence不包含指定radix中可解析的无符号long，或者radix小于Character.MIN_RADIX或大于Character.MAX_RADIX。
      自：
      9

    • parseUnsignedLong

      public static long parseUnsignedLong(String s) throws NumberFormatException
      将字符串参数解析为无符号十进制long。字符串中的字符必须都是十进制数字，除非第一个字符是ASCII加号 '+'（'\u002B'）。返回结果整数值，就像将参数和基数10作为参数传递给parseUnsignedLong(java.lang.String, int)方法一样。
      参数：
      s - 包含要解析的无符号long表示的String。
      返回：
      十进制字符串参数表示的无符号long值。
      抛出：
      NumberFormatException - 如果字符串不包含可解析的无符号整数。
      自：
      1.8

    • valueOf

      public static Long valueOf(String s, int radix) throws NumberFormatException
      返回一个Long对象，该对象保存使用第二个参数给定的基数解析时从指定的String中提取的值。第一个参数被解释为表示由第二个参数指定的基数中的有符号long，就像将参数传递给parseLong(java.lang.String, int)方法一样。结果是一个表示字符串指定的long值的Long对象。

      换句话说，此方法返回等于以下值的Long对象：

      Long.valueOf(Long.parseLong(s, radix))
      参数:
      s - 要解析的字符串
      radix - 用于解释s的基数
      返回:
      一个Long对象，其中包含由指定基数中的字符串参数表示的值。
      抛出:
      NumberFormatException - 如果String不包含可解析的long。

    • valueOf

      public static Long valueOf(String s) throws NumberFormatException
      返回一个包含指定String值的Long对象。该参数被解释为表示有符号十进制long，就好像该参数被传递给parseLong(java.lang.String)方法一样。结果是一个代表字符串指定的整数值的Long对象。

      换句话说，该方法返回一个等于以下值的Long对象：

      Long.valueOf(Long.parseLong(s))
      参数:
      s - 要解析的字符串。
      返回:
      一个Long对象，其中包含由字符串参数表示的值。
      抛出:
      NumberFormatException - 如果字符串无法解析为long。

    • valueOf

      public static Long valueOf(long l)
      返回表示指定long值的Long实例。如果不需要新的Long实例，则通常应优先使用此方法，因为该方法通过缓存经常请求的值，可能会获得显着更好的空间和时间性能。该方法始终会缓存范围在-128到127之间的值，并且可能会缓存此范围之外的其他值。
      参数:
      l - 一个long值。
      返回:
      代表l的Long实例。
      自版本:
      1.5

    • decode

      public static Long decode(String nm) throws NumberFormatException
      将一个String解码为一个Long。接受由以下语法给出的十进制、十六进制和八进制数字：
      可解码字符串:
      符号可选 十进制数
      符号可选 0x 十六进制数字
      符号可选 0X 十六进制数字
      符号可选 # 十六进制数字
      符号可选 0 八进制数字
      符号:
      -
      +
      十进制数、十六进制数字和八进制数字的定义如Java语言规范第3.10.1节中所定义的，但是在数字之间不接受下划线。

      在可选符号和/或基数指示符（“0x”、“0X”、“#”或前导零）之后的字符序列被解析为具有指定基数（10、16或8）的Long.parseLong方法。这些字符序列必须表示正值，否则将抛出NumberFormatException。如果指定的String的第一个字符是减号，则结果将被否定。在String中不允许有空白字符。

      参数:
      nm - 要解码的String。
      返回:
      一个Long对象，其中包含由nm表示的long值
      抛出:
      NumberFormatException - 如果String不包含可解析的long。
      自版本:
      1.2
      参见:

    • byteValue

      public byte byteValue()
      返回此Long的值作为缩小的原始转换后的byte。
      覆盖:
      byteValue 在类 Number
      返回:
      转换为byte类型后表示的对象的数值。
      参见Java语言规范:
      5.1.3 缩小原始转换

    • shortValue

      public short shortValue()
      返回此Long的值作为缩小的原始转换后的short。
      覆盖:
      shortValue 在类 Number
      返回:
      转换为short类型后表示的对象的数值。
      参见Java语言规范:
      5.1.3 缩小原始转换

    • intValue

      public int intValue()
      返回此Long的值作为缩小的原始转换后的int。
      由以下指定:
      intValue 在类 Number
      返回:
      转换为int类型后表示的对象的数值。
      参见Java语言规范:
      5.1.3 缩小原始转换

    • longValue

      public long longValue()
      返回此Long的值作为long值。
      由以下指定:
      longValue 在类 Number
      返回:
      转换为long类型后表示的对象的数值。

    • floatValue

      public float floatValue()
      返回此Long的值作为扩宽的原始转换后的float。
      由以下指定:
      floatValue 在类 Number
      返回:
      转换为float类型后表示的对象的数值。
      参见Java语言规范:
      5.1.2 扩宽原始转换

    • doubleValue

      public double doubleValue()
      返回此Long的值作为扩宽的原始转换后的double。
      由以下指定:
      doubleValue 在类 Number
      返回:
      转换为double类型后表示的对象的数值。
      参见Java语言规范:
      5.1.2 扩宽原始转换

    • toString

      public String toString()
      返回表示此Long值的String对象。该值被转换为有符号十进制表示形式，并作为字符串返回，就好像long值被作为参数传递给toString(long)方法一样。
      覆盖:
      toString 在类 Object
      返回:
      该对象的值的十进制表示形式的字符串。

    • hashCode

      public int hashCode()
      返回此Long的哈希码。结果是该Long对象持有的原始long值的两半的异或。也就是说，哈希码是以下表达式的值：
      (int)(this.longValue()^(this.longValue()>>>32))
      覆盖:
      hashCode 在类 Object
      返回:
      该对象的哈希码值。
      参见:

    • hashCode

      public static int hashCode(long value)
      返回long值的哈希码；与Long.hashCode()兼容。
      参数:
      value - 要哈希的值
      返回:
      一个long值的哈希码值。
      自版本:
      1.8

    • equals

      public boolean equals(Object obj)
      将此对象与指定对象进行比较。结果为true当且仅当参数不为null且为包含与此对象相同long值的Long对象时。
      覆盖:
      equals 在类 Object
      参数:
      obj - 要比较的对象。
      返回:
      如果对象相同，则为true；否则为false。
      参见:

    • getLong

      public static Long getLong(String nm)
      Determines the long value of the system property with the specified name.

      The first argument is treated as the name of a system property. System properties are accessible through the System.getProperty(java.lang.String) method. The string value of this property is then interpreted as a long value using the grammar supported by decode and a Long object representing this value is returned.

      If there is no property with the specified name, if the specified name is empty or null, or if the property does not have the correct numeric format, then null is returned.

      In other words, this method returns a Long object equal to the value of:

      getLong(nm, null)
      Parameters:
      nm - property name.
      Returns:
      the Long value of the property.
      Throws:
      SecurityException - for the same reasons as System.getProperty
      See Also:

    • getLong

      public static Long getLong(String nm, long val)
      Determines the long value of the system property with the specified name.

      The first argument is treated as the name of a system property. System properties are accessible through the System.getProperty(java.lang.String) method. The string value of this property is then interpreted as a long value using the grammar supported by decode and a Long object representing this value is returned.

      The second argument is the default value. A Long object that represents the value of the second argument is returned if there is no property of the specified name, if the property does not have the correct numeric format, or if the specified name is empty or null.

      In other words, this method returns a Long object equal to the value of:

      getLong(nm, Long.valueOf(val))
      but in practice it may be implemented in a manner such as: 
       Long result = getLong(nm, null);
 return (result == null) ? Long.valueOf(val) : result;
      to avoid the unnecessary allocation of a Long object when the default value is not needed.
      Parameters:
      nm - property name.
      val - default value.
      Returns:
      the Long value of the property.
      Throws:
      SecurityException - for the same reasons as System.getProperty
      See Also:

    • getLong

      public static Long getLong(String nm, Long val)
      Returns the long value of the system property with the specified name. The first argument is treated as the name of a system property. System properties are accessible through the System.getProperty(java.lang.String) method. The string value of this property is then interpreted as a long value, as per the decode method, and a Long object representing this value is returned; in summary:
      • If the property value begins with the two ASCII characters 0x or the ASCII character #, not followed by a minus sign, then the rest of it is parsed as a hexadecimal integer exactly as for the method valueOf(java.lang.String, int) with radix 16.
      • If the property value begins with the ASCII character 0 followed by another character, it is parsed as an octal integer exactly as by the method valueOf(java.lang.String, int) with radix 8.
      • Otherwise the property value is parsed as a decimal integer exactly as by the method valueOf(java.lang.String, int) with radix 10.

      Note that, in every case, neither L ('\u004C') nor l ('\u006C') is permitted to appear at the end of the property value as a type indicator, as would be permitted in Java programming language source code.

      The second argument is the default value. The default value is returned if there is no property of the specified name, if the property does not have the correct numeric format, or if the specified name is empty or null.

      Parameters:
      nm - property name.
      val - default value.
      Returns:
      the Long value of the property.
      Throws:
      SecurityException - for the same reasons as System.getProperty
      See Also:

    • compareTo

      public int compareTo(Long anotherLong)
      Compares two Long objects numerically.
      Specified by:
      compareTo in interface Comparable<Long>
      Parameters:
      anotherLong - the Long to be compared.
      Returns:
      the value 0 if this Long is equal to the argument Long; a value less than 0 if this Long is numerically less than the argument Long; and a value greater than 0 if this Long is numerically greater than the argument Long (signed comparison).
      Since:
      1.2

    • compare

      public static int compare(long x, long y)
      Compares two long values numerically. The value returned is identical to what would be returned by: 
          Long.valueOf(x).compareTo(Long.valueOf(y))
      Parameters:
      x - the first long to compare
      y - the second long to compare
      Returns:
      the value 0 if x == y; a value less than 0 if x < y; and a value greater than 0 if x > y
      Since:
      1.7

    • compareUnsigned

      public static int compareUnsigned(long x, long y)
      Compares two long values numerically treating the values as unsigned.
      Parameters:
      x - the first long to compare
      y - the second long to compare
      Returns:
      the value 0 if x == y; a value less than 0 if x < y as unsigned values; and a value greater than 0 if x > y as unsigned values
      Since:
      1.8

    • divideUnsigned

      public static long divideUnsigned(long dividend, long divisor)
      Returns the unsigned quotient of dividing the first argument by the second where each argument and the result is interpreted as an unsigned value.

      Note that in two's complement arithmetic, the three other basic arithmetic operations of add, subtract, and multiply are bit-wise identical if the two operands are regarded as both being signed or both being unsigned. Therefore separate addUnsigned, etc. methods are not provided.

      Parameters:
      dividend - the value to be divided
      divisor - the value doing the dividing
      Returns:
      the unsigned quotient of the first argument divided by the second argument
      Since:
      1.8
      See Also:

    • remainderUnsigned

      public static long remainderUnsigned(long dividend, long divisor)
      Returns the unsigned remainder from dividing the first argument by the second where each argument and the result is interpreted as an unsigned value.
      Parameters:
      dividend - the value to be divided
      divisor - the value doing the dividing
      Returns:
      the unsigned remainder of the first argument divided by the second argument
      Since:
      1.8
      See Also:

    • highestOneBit

      public static long highestOneBit(long i)
      Returns a long value with at most a single one-bit, in the position of the highest-order ("leftmost") one-bit in the specified long value. Returns zero if the specified value has no one-bits in its two's complement binary representation, that is, if it is equal to zero.
      Parameters:
      i - the value whose highest one bit is to be computed
      Returns:
      a long value with a single one-bit, in the position of the highest-order one-bit in the specified value, or zero if the specified value is itself equal to zero.
      Since:
      1.5

    • lowestOneBit

      public static long lowestOneBit(long i)
      Returns a long value with at most a single one-bit, in the position of the lowest-order ("rightmost") one-bit in the specified long value. Returns zero if the specified value has no one-bits in its two's complement binary representation, that is, if it is equal to zero.
      Parameters:
      i - the value whose lowest one bit is to be computed
      Returns:
      a long value with a single one-bit, in the position of the lowest-order one-bit in the specified value, or zero if the specified value is itself equal to zero.
      Since:
      1.5

    • numberOfLeadingZeros

      public static int numberOfLeadingZeros(long i)
      返回指定long值的二进制补码表示中最高位（“最左侧”）一位前面的零位数。如果指定值在其二进制补码表示中没有一位为1，换句话说，如果它等于零，则返回64。

      请注意，此方法与以2为底的对数密切相关。对于所有正long值x：

      • floor(log2(x)) = 63 - numberOfLeadingZeros(x)
      • ceil(log2(x)) = 64 - numberOfLeadingZeros(x - 1)
      参数：
      i - 要计算其前导零位数的值
      返回：
      指定long值的二进制补码表示中最高位（“最左侧”）一位前面的零位数，如果该值等于零，则返回64。
      自：
      1.5

    • numberOfTrailingZeros

      public static int numberOfTrailingZeros(long i)
      返回指定long值的二进制补码表示中最低位（“最右侧”）一位后面的零位数。如果指定值在其二进制补码表示中没有一位为1，换句话说，如果它等于零，则返回64。
      参数：
      i - 要计算其尾随零位数的值
      返回：
      指定long值的二进制补码表示中最低位（“最右侧”）一位后面的零位数，如果该值等于零，则返回64。
      自：
      1.5

    • bitCount

      public static int bitCount(long i)
      返回指定long值的二进制补码表示中的一位数。此函数有时被称为种群计数。
      参数：
      i - 要计算其位数的值
      返回：
      指定long值的二进制补码表示中的一位数。
      自：
      1.5

    • rotateLeft

      public static long rotateLeft(long i, int distance)
      返回通过将指定long值的二进制补码表示向左旋转指定位数获得的值。（从左侧或高位移出的位重新进入右侧或低位。）

      请注意，使用负距离进行左旋转等效于右旋转：rotateLeft(val, -distance) == rotateRight(val, distance)。还请注意，通过64的任何倍数旋转是一个无操作，因此旋转距离的除最后六位外的所有位都可以被忽略，即使距离为负数：rotateLeft(val, distance) == rotateLeft(val, distance & 0x3F)。

      参数：
      i - 要向左旋转其位的值
      distance - 要向左旋转的位数
      返回：
      通过将指定long值的二进制补码表示向左旋转指定位数获得的值。
      自：
      1.5

    • rotateRight

      public static long rotateRight(long i, int distance)
      返回通过将指定long值的二进制补码表示向右旋转指定位数获得的值。（从右侧或低位移出的位重新进入左侧或高位。）

      请注意，使用负距离进行右旋转等效于左旋转：rotateRight(val, -distance) == rotateLeft(val, distance)。还请注意，通过64的任何倍数旋转是一个无操作，因此旋转距离的除最后六位外的所有位都可以被忽略，即使距离为负数：rotateRight(val, distance) == rotateRight(val, distance & 0x3F)。

      参数：
      i - 要向右旋转其位的值
      distance - 要向右旋转的位数
      返回：
      通过将指定long值的二进制补码表示向右旋转指定位数获得的值。
      自：
      1.5

    • reverse

      public static long reverse(long i)
      返回通过颠倒指定long值的二进制补码表示中位的顺序获得的值。
      参数：
      i - 要颠倒位顺序的值
      返回：
      通过颠倒指定long值的二进制补码表示中位的顺序获得的值。
      自：
      1.5

    • compress

      public static long compress(long i, long mask)
      返回通过根据指定的位掩码压缩指定long值i的位获得的值。

      对于掩码的每个一位值mb，从最低有效位到最高有效位，与mb在相同位位置的i的位值被连续地从最低有效位位置开始分配给压缩值。压缩值的所有上部剩余位被设置为零。

      API注释：
      考虑将十六进制值的数字压缩的简单情况： 
      // 将drink压缩为food
compress(0xCAFEBABEL, 0xFF00FFF0L) == 0xCABABL
      从最右侧的最低有效十六进制数字开始，掩码0xFF00FFF0选择0xCAFEBABE的位置1、2、3、6和7的十六进制数字。所选数字以相同顺序连续出现在结果压缩值的数字位置0中。

      以下等式都返回true，有助于理解compress的行为：

      // 如果位置n处的位为1，则返回1
compress(x, 1L << n) == (x >> n & 1)

// 逻辑右移
compress(x, -1L << n) == x >>> n

// 掩码未覆盖的任何位都将被忽略
compress(x, m) == compress(x & m, m)

// 通过自身压缩值
compress(m, m) == (m == -1 || m == 0) ? m : (1L << bitCount(m)) - 1

// 扩展然后使用相同掩码压缩
compress(expand(x, m), m) == x & compress(m, m)

      羊群与山羊（SAG）操作（参见《黑客的乐趣》，第7.7节）可以实现如下：

      long compressLeft(long i, long mask) {
    // 此实现遵循《黑客的乐趣》中的描述，这是具有信息性的。更优化的实现是：
    //   Long.compress(i, mask) << -Long.bitCount(mask)
    return Long.reverse(
        Long.compress(Long.reverse(i), Long.reverse(mask)));
}

long sag(long i, long mask) {
    return compressLeft(i, mask) | Long.compress(i, ~mask);
}

// 将羊群与山羊分开
sag(0x00000000_CAFEBABEL, 0xFFFFFFFF_FF00FFF0L) == 0x00000000_CABABFEEL
      参数：
      i - 要压缩其位的值
      mask - 位掩码
      返回：
      压缩值
      自：
      19
      另请参见：

    • expand

      public static long expand(long i, long mask)
      返回通过根据指定的位掩码扩展指定long值i的位获得的值。

      对于掩码的每个一位值mb，从最低有效位到最高有效位，从最低有效位开始，下一个连续的i位值被分配给与mb相同位位置的扩展值。扩展值的所有其他剩余位被设置为零。

      API注释:
      考虑扩展十六进制值的数字的简单情况： 
      expand(0x0000CABABL, 0xFF00FFF0L) == 0xCA00BAB0L
      从最右边位置0处的最不重要的十六进制数字开始，掩码0xFF00FFF0选择了0x0000CABAB的前五个十六进制数字。所选数字按顺序出现在结果扩展值的位置1、2、3、6和7处。

      以下等式都返回true，有助于理解expand的行为：

      // 逻辑右移位于位置0的位
expand(x, 1L << n) == (x & 1) << n

// 逻辑右移
expand(x, -1L << n) == x << n

// 扩展所有位返回掩码
expand(-1L, m) == m

// 掩码未覆盖的任何位将被忽略
expand(x, m) == expand(x, m) & m

// 压缩然后使用相同掩码扩展
expand(compress(x, m), m) == x & m

      用于确定long值中具有索引n的一位的位置的选择操作可以实现如下：

      long select(long i, long n) {
    // i（掩码）中具有索引n的一位
    long nthBit = Long.expand(1L << n, i);
    // 具有索引n的一位的位位置
    return Long.numberOfTrailingZeros(nthBit);
}

// 具有索引0的一位位于位位置1
select(0b10101010_10101010, 0) == 1
// 具有索引3的一位位于位位置7
select(0b10101010_10101010, 3) == 7
      参数:
      i - 要扩展其位的值
      mask - 位掩码
      返回:
      扩展后的值
      自:
      19
      参见:

    • signum

      public static int signum(long i)
      返回指定long值的符号函数。（如果指定值为负，则返回值为-1；如果指定值为零，则返回值为0；如果指定值为正，则返回值为1。）
      参数:
      i - 要计算其符号的值
      返回:
      指定long值的符号函数。
      自:
      1.5

    • reverseBytes

      public static long reverseBytes(long i)
      返回指定long值的补码表示中字节顺序颠倒后得到的值。
      参数:
      i - 要颠倒字节的值
      返回:
      指定long值中字节颠倒后得到的值。
      自:
      1.5

    • sum

      public static long sum(long a, long b)
      将两个long值按照+运算符相加。
      参数:
      a - 第一个操作数
      b - 第二个操作数
      返回:
      a和b的和
      自:
      1.8
      参见:

    • max

      public static long max(long a, long b)
      返回两个long值中较大的值，就像调用Math.max一样。
      参数:
      a - 第一个操作数
      b - 第二个操作数
      返回:
      a和b中较大的值
      自:
      1.8
      参见:

    • min

      public static long min(long a, long b)
      返回两个long值中较小的值，就像调用Math.min一样。
      参数:
      a - 第一个操作数
      b - 第二个操作数
      返回:
      a和b中较小的值
      自:
      1.8
      参见:

    • describeConstable

      public Optional<Long> describeConstable()
      返回包含此实例的标准描述符的Optional，即实例本身。
      在接口中指定:
      describeConstable in interface Constable
      返回:
      描述Long实例的Optional
      自:
      12

    • resolveConstantDesc

      public Long resolveConstantDesc(MethodHandles.Lookup lookup)
      将此实例解析为ConstantDesc，其结果是实例本身。
      在接口中指定:
      resolveConstantDesc in interface ConstantDesc
      参数:
      lookup - 忽略
      返回:
      Long实例
      自:
      12