模块 java.base
包 java.lang

类 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 时有用的其他常量和方法。

这是一个value-based类；程序员应该将 equal 的实例视为可互换的，并且不应使用实例进行同步，否则可能会发生不可预测的行为。例如，在未来的版本中，同步可能会失败。

实施说明：“位旋转”方法（例如 highestOneBit 和 numberOfTrailingZeros ）的实施基于 Henry S. Warren, Jr. 的材料黑客的喜悦，（艾迪生韦斯利，2002 年）。

自从：
1.0
参见：

  • 字段摘要

    字段
    修饰符和类型
    Field
    描述
    static final int
    BYTES
    用于以二进制补码形式表示 long 值的字节数。
    static final long
    MAX_VALUE
    一个保持最大值的常量 long 可以有，263-1.
    static final long
    MIN_VALUE
    一个保持最小值的常数 a long 可以有，-263.
    static final int
    SIZE
    用于以二进制补码形式表示 long 值的位数。
    static final Class<Long>
    TYPE
    代表原始类型 long 的 Class 实例。

  • 构造方法总结

    构造方法
    构造方法
    描述
    Long(long value)
    已弃用，将被删除：此 API 元素可能会在未来版本中删除。
    使用此构造方法很少是合适的。
    Long(String s)
    已弃用，将被删除：此 API 元素可能会在未来版本中删除。
    使用此构造方法很少是合适的。

  • 方法总结

    修饰符和类型
    方法
    描述
    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
    decode(String nm)
    将 String 解码为 Long 。
    Optional<Long>
    describeConstable()
    返回一个 Optional ，其中包含此实例的标称描述符，即实例本身。
    static long
    divideUnsigned(long dividend, long divisor)
    返回第一个参数除以第二个参数的无符号商，其中每个参数和结果都被解释为无符号值。
    double
    doubleValue()
    在扩大原始转换后将此 Long 的值作为 double 返回。
    boolean
    equals(Object obj)
    将此对象与指定对象进行比较。
    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 参数的字符串表示形式返回为基数为 2 的无符号整数。
    static String
    toHexString(long i)
    以 16 进制的无符号整数形式返回 long 参数的字符串表示形式。
    static String
    toOctalString(long i)
    将 long 参数的字符串表示形式返回为基数为 8 的无符号整数。
    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)
    返回一个 Long 对象，其中包含指定的 String 的值。
    static Long
    valueOf(String s, int radix)
    返回一个 Long 对象，其中包含在使用第二个参数给出的基数进行解析时从指定的 String 中提取的值。

    在类 java.lang.Object 中声明的方法

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

  • 字段详细信息

    • MIN_VALUE

      @Native public static final long MIN_VALUE
      一个保持最小值的常数 a 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
      参见：

  • 构造方法详细信息

    • Long

      @Deprecated (since ="9", forRemoval =true) public Long(long value)
      已弃用，将被删除：此 API 元素可能会在未来版本中删除。
      使用此构造函数很少是合适的。静态工厂 valueOf(long) 通常是更好的选择，因为它可能会产生更好的空间和时间性能。
      构造一个新分配的 Long 对象，表示指定的 long 参数。
      参数：
      value - 由 Long 对象表示的值。

    • Long

      @Deprecated (since ="9", forRemoval =true) public Long(String  s) throws NumberFormatException
      已弃用，将被删除：此 API 元素可能会在未来版本中删除。
      使用此构造函数很少是合适的。使用 parseLong(String) 将字符串转换为 long 基元，或使用 valueOf(String) 将字符串转换为 Long 对象。
      构造一个新分配的 Long 对象，该对象表示 String 参数指示的 long 值。字符串转换为 long 值的方式与 parseLong 方法用于基数 10 的方式完全相同。
      参数：
      s - 要转换为 Long 的 String。
      抛出：
      NumberFormatException - 如果 String 不包含可解析的 long 。

  • 方法详情

    • 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)
      以 16 进制的无符号整数形式返回 long 参数的字符串表示形式。

      无符号 long 值是参数加 264如果参数是否定的；否则，它等于参数。此值将转换为十六进制（基数 16）的 ASCII 数字字符串，没有额外的前导 0 s。

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

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

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

    • toOctalString

      public static String  toOctalString(long i)
      将 long 参数的字符串表示形式返回为基数为 8 的无符号整数。

      无符号 long 值是参数加 264如果参数是否定的；否则，它等于参数。此值将转换为八进制（基数 8）的 ASCII 数字字符串，没有额外的前导 0 s。

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

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

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

    • toBinaryString

      public static String  toBinaryString(long i)
      将 long 参数的字符串表示形式返回为基数为 2 的无符号整数。

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

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

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

      参数：
      i - 要转换为字符串的 long。
      返回：
      二进制参数表示的无符号 long 值的字符串表示形式（基数 2）。
      自从：
      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 编程语言源代码中是允许的——除了 L 或 l 可以作为类型指示符出现大于或等于 22 的基数的数字。

      如果出现以下任何一种情况，将抛出NumberFormatException类型的异常：

      • 第一个参数是 null 或者是一个长度为零的字符串。
      • radix 小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX 。
      • 字符串的任何字符都不是指定基数的数字，但第一个字符可能是减号 '-' ('\u002d' ) 或加号 '+' ('\u002B' )，前提是字符串长于长度 1。
      • 字符串表示的值不是 long 类型的值。

      示例：

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

    • parseLong

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

      该方法不采取措施防止 CharSequence 在解析时发生突变。

      参数：
      s - 包含要解析的 long 表示的 CharSequence
      beginIndex - 开始索引，包括在内。
      endIndex - 结束索引，独占。
      radix - 解析 s 时要使用的基数。
      返回：
      由指定基数中的子序列表示的带符号的 long。
      抛出：
      NullPointerException - 如果 s 为空。
      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
      将 CharSequence 参数解析为指定 radix 中的无符号 long，从指定的 beginIndex 开始并扩展到 endIndex - 1。

      该方法不采取措施防止 CharSequence 在解析时发生突变。

      参数：
      s - 包含要解析的无符号 long 表示的 CharSequence
      beginIndex - 开始索引，包括在内。
      endIndex - 结束索引，独占。
      radix - 解析 s 时要使用的基数。
      返回：
      由指定基数中的子序列表示的无符号 long。
      抛出：
      NullPointerException - 如果 s 为空。
      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 - 一个 String 包含要解析的无符号 long 表示
      返回：
      由十进制字符串参数表示的无符号 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 对象，其值等于：

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

    • valueOf

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

      换句话说，此方法返回一个 Long 对象，其值等于：

      new Long(Long.parseLong(s))
      参数：
      s - 要解析的字符串。
      返回：
      一个 Long 对象保存由字符串参数表示的值。
      抛出：
      NumberFormatException - 如果字符串无法解析为 long。

    • valueOf

      public static Long  valueOf(long l)
      返回代表指定 long 值的 Long 实例。如果不需要新的 Long 实例，通常应优先使用此方法而不是构造函数 Long(long) ，因为此方法可能会通过缓存频繁请求的值来产生明显更好的空间和时间性能。此方法将始终缓存 -128 到 127（含）范围内的值，并可能缓存此范围之外的其他值。
      参数：
      l - 长值。
      返回：
      代表 l 的 Long 实例。
      自从：
      1.5

    • decode

      public static Long  decode(String  nm) throws NumberFormatException
      将 String 解码为 Long 。接受由以下语法给出的十进制、十六进制和八进制数：
      可解码字符串：
      符号选择 DecimalNumeral
      符号选择 0x HexDigits
      符号选择 0X HexDigits
      符号选择 # HexDigits
      符号选择 0 OctalDigits
      符号：
      -
      +
      DecimalNumeral, HexDigits， 和OctalDigits的定义见 3.10.1 节Java 语言规范, 除了数字之间不接受下划线。

      可选符号和/或基数说明符（“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 中
      返回：
      此对象的值以 10 为基数的字符串表示形式。

    • 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)
      将此对象与指定对象进行比较。当且仅当参数不是 null 并且是包含与该对象相同的 long 值的 Long 对象时，结果为 true。
      重写：
      equals 在类 Object 中
      参数：
      obj - 要与之比较的对象。
      返回：
      true 如果对象相同； false否则。
      参见：

    • getLong

      public static Long  getLong(String  nm)
      确定具有指定名称的系统属性的 long 值。

      第一个参数被视为系统属性的名称。系统属性可通过 System.getProperty(java.lang.String) 方法访问。然后使用 decode 支持的语法将此属性的字符串值解释为 long 值，并返回表示此值的 Long 对象。

      如果没有具有指定名称的属性，如果指定名称为空或 null ，或者如果属性没有正确的数字格式，则返回 null 。

      换句话说，此方法返回一个 Long 对象，其值等于：

      getLong(nm, null)
      参数：
      nm - 属性名称。
      返回：
      属性的 Long 值。
      抛出：
      SecurityException - 原因与 System.getProperty 相同
      参见：

    • getLong

      public static Long  getLong(String  nm, long val)
      确定具有指定名称的系统属性的 long 值。

      第一个参数被视为系统属性的名称。系统属性可通过 System.getProperty(java.lang.String) 方法访问。然后使用 decode 支持的语法将此属性的字符串值解释为 long 值，并返回表示此值的 Long 对象。

      第二个参数是默认值。如果没有指定名称的属性，如果属性没有正确的数字格式，或者如果指定的名称为空或 null，则返回表示第二个参数值的 Long 对象。

      换句话说，此方法返回一个 Long 对象，其值等于：

      getLong(nm, new Long(val))
      但实际上它可能以如下方式实现： 
       Long result = getLong(nm, null);
 return (result == null) ? new Long(val) : result;
      避免在不需要默认值时不必要地分配 Long 对象。
      参数：
      nm - 属性名称。
      val - 默认值。
      返回：
      属性的 Long 值。
      抛出：
      SecurityException - 原因与 System.getProperty 相同
      参见：

    • getLong

      public static Long  getLong(String  nm, Long  val)
      返回具有指定名称的系统属性的 long 值。第一个参数被视为系统属性的名称。系统属性可通过 System.getProperty(java.lang.String) 方法访问。然后根据 decode 方法将此属性的字符串值解释为 long 值，并返回代表该值的 Long 对象；总之：
      • 如果属性值以两个 ASCII 字符 0x 或 ASCII 字符 # 开头，后面没有减号，则其余部分将被解析为十六进制整数，与基数为 16 的方法 valueOf(java.lang.String, int) 完全相同。
      • 如果属性值以 ASCII 字符 0 开头，后跟另一个字符，则它被解析为八进制整数，与方法 valueOf(java.lang.String, int) 完全相同，基数为 8。
      • 否则，属性值将被解析为十进制整数，与方法 valueOf(java.lang.String, int) 完全相同，基数为 10。

      请注意，在任何情况下，L ('\u004C') 和 l ('\u006C') 都不允许作为类型指示符出现在属性值的末尾，这在 Java 编程语言源代码中是允许的。

      第二个参数是默认值。如果没有指定名称的属性，如果属性没有正确的数字格式，或者如果指定的名称为空或 null ，则返回默认值。

      参数：
      nm - 属性名称。
      val - 默认值。
      返回：
      属性的 Long 值。
      抛出：
      SecurityException - 原因与 System.getProperty 相同
      参见：

    • compareTo

      public int compareTo(Long  anotherLong)
      在数值上比较两个 Long 对象。
      指定者：
      compareTo 在接口 Comparable<Long> 中
      参数：
      anotherLong - 要比较的 Long。
      返回：
      值 0 如果这个 Long 等于参数 Long ；如果此 Long 在数值上小于参数 Long ，则该值小于 0 ；和大于 0 的值，如果此 Long 在数值上大于参数 Long（有符号比较）。
      自从：
      1.2

    • compare

      public static int compare(long x, long y)
      以数字方式比较两个 long 值。返回的值与将返回的值相同： 
        Long.valueOf(x).compareTo(Long.valueOf(y))
      参数：
      x - 第一个要比较的 long
      y - 要比较的第二个 long
      返回：
      值 0 如果 x == y ；如果 x < y 小于 0 的值；如果 x > y，则值大于 0
      自从：
      1.7

    • compareUnsigned

      public static int compareUnsigned(long x, long y)
      比较两个 long 值，在数值上将值视为无符号。
      参数：
      x - 第一个要比较的 long
      y - 要比较的第二个 long
      返回：
      值 0 如果 x == y ；如果 x < y 为无符号值，则小于 0 的值；如果 x > y 为无符号值，则值大于 0
      自从：
      1.8

    • divideUnsigned

      public static long divideUnsigned(long dividend, long divisor)
      返回第一个参数除以第二个参数的无符号商，其中每个参数和结果都被解释为无符号值。

      请注意，在二进制补码运算中，如果两个操作数都被视为有符号或无符号，则加、减和乘这三个其他基本算术运算按位相同。因此，不提供单独的 addUnsigned 等方法。

      参数：
      dividend - 要划分的值
      divisor - 进行除法的值
      返回：
      第一个参数除以第二个参数的无符号商
      自从：
      1.8
      参见：

    • remainderUnsigned

      public static long remainderUnsigned(long dividend, long divisor)
      返回第一个参数除以第二个参数的无符号余数，其中每个参数和结果都被解释为无符号值。
      参数：
      dividend - 要划分的值
      divisor - 进行除法的值
      返回：
      第一个参数除以第二个参数的无符号余数
      自从：
      1.8
      参见：

    • highestOneBit

      public static long highestOneBit(long i)
      在指定的 long 值中最高位（“最左边”）一位的位置返回一个最多只有一位的 long 值。如果指定值在其补码二进制表示中没有一位，即等于零，则返回零。
      参数：
      i - 要计算其最高一位的值
      返回：
      具有单个一位的 long 值，位于指定值中最高位的位置，如果指定值本身等于零，则为零。
      自从：
      1.5

    • lowestOneBit

      public static long lowestOneBit(long i)
      在指定的 long 值中最低位（“最右边”）一位的位置返回一个最多只有一位的 long 值。如果指定值在其补码二进制表示中没有一位，即等于零，则返回零。
      参数：
      i - 要计算其最低一位的值
      返回：
      具有单个一位的 long 值，位于指定值的最低位一位的位置，如果指定值本身等于零，则为零。
      自从：
      1.5

    • numberOfLeadingZeros

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

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

      • 地板（日志2(x)) = 63 - numberOfLeadingZeros(x)
      • 天花板（日志2(x)) = 64 - numberOfLeadingZeros(x - 1)
      参数：
      i - 要计算其前导零数的值
      返回：
      指定 long 值的二进制补码表示中最高阶（“最左边”）一位之前的零位数，如果该值等于零，则为 64。
      自从：
      1.5

    • numberOfTrailingZeros

      public static int numberOfTrailingZeros(long i)
      返回指定 long 值的二进制补码表示形式中最低位（“最右边”）一位之后的零位数。如果指定值在其二进制补码表示中没有一位，换句话说，如果它等于零，则返回 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

    • 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 在接口 Constable 中
      返回：
      Optional 描述了 Long 实例
      自从：
      12

    • resolveConstantDesc

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