实现的所有接口

Serializable ， Comparable<Long>
```
public final class Longextends Numberimplements Comparable<Long>
```
Long类在对象中包装基本类型long的值。 Long类型的对象包含单个字段，其类型为long 。
此外，此类提供了几种将long转换为String和String转换为long ，以及处理long时有用的其他常量和方法。

实施注释：“bit twiddling”方法（如highestOneBit和numberOfTrailingZeros ）的实现基于Henry S. Warren，Jr。的Hacker's Delight （Addison Wesley，2002）的材料。

从以下版本开始：

1.0

另请参见：

Serialized Form

字段汇总

字段
变量和类型	字段	描述
`static int`	`BYTES`	用于表示二进制补码二进制形式的 `long`值的字节数。
`static long`	`MAX_VALUE`	保持 `long`可以具有的最大值的常数，2 ⁶³ -1。
`static long`	`MIN_VALUE`	持有 `long`最小值的常数，-2 ⁶³ 。
`static int`	`SIZE`	用于表示二进制补码二进制形式的 `long`值的位数。
`static 类<Long>`	`TYPE`	`类`实例表示基本类型 `long` 。

构造方法摘要

构造方法
构造器	描述
`Long(long value)`	已过时。使用此构造函数很少是合适的。
`Long(String s)`	已过时。使用此构造函数很少是合适的。

方法摘要

所有方法静态方法实例方法具体的方法
变量和类型	方法	描述
`static int`	`bitCount(long i)`	返回指定的 `long`值的二进制补码表示形式中的 `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` 。
`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`值中较大的一个， `long`调用 `Math.max`一样。
`static long`	`min(long a, long b)`	返回两个 `long`值中较小的一个， `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`参数作为有符号`long`指定`radix` ，在指定的开始`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`参数为一个无符号`long`在指定的`radix` ，在指定的开始`beginIndex`并延伸到`endIndex - 1` 。
`static long`	`parseUnsignedLong(String s)`	将字符串参数解析为无符号十进制 `long` 。
`static long`	`parseUnsignedLong(String s, int radix)`	将字符串参数解析为第二个参数指定的基数中的无符号 `long` 。
`static long`	`remainderUnsigned(long dividend, long divisor)`	返回将第一个参数除以第二个参数的无符号余数，其中每个参数和结果都被解释为无符号值。
`static long`	`reverse(long i)`	返回通过反转指定的 `long`值的二进制补码表达式中的位顺序获得的值。
`static long`	`reverseBytes(long i)`	返回通过反转指定的 `long`值的二进制补码表示中的字节顺序获得的值。
`static long`	`rotateLeft(long i, int distance)`	返回通过旋转指定 `long`剩余的指定 `long`值的二进制补码表示形式获得的值。
`static long`	`rotateRight(long i, int distance)`	返回通过将指定的 `long`值的二进制补码表达式旋转指定的 `long`值。
`short`	`shortValue()`	在缩小基元转换后，将此 `Long`的值作为 `short`返回。
`static int`	`signum(long i)`	返回指定的 `long`值的signum函数。
`static long`	`sum(long a, long b)`	根据+运算符一起添加两个 `long`值。
`static String`	`toBinaryString(long i)`	返回 `long`参数的字符串表示形式，作为base 2中的无符号整数。
`static String`	`toHexString(long i)`	返回 `long`参数的字符串表示形式，作为基数为16的无符号整数。
`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
```
@Nativepublic static final long MIN_VALUE
```
    保持最小值a long常数，-2 ⁶³ 。
    
    另请参见：
    
    常数字段值
  - MAX_VALUE
```
@Nativepublic static final long MAX_VALUE
```
    保持 long可以具有的最大值的常数，2 ⁶³ -1。
    
    另请参见：
    
    常数字段值
  - TYPE
```
public static final 类<Long> TYPE
```
    类实例表示基本类型 long 。
    
    从以下版本开始：
    
    1.1
  - SIZE
```
@Nativepublic static final int SIZE
```
    用于表示二进制补码二进制形式的 long值的位数。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    常数字段值
  - BYTES
```
public static final int BYTES
```
    用于表示二进制补码二进制形式的 long值的字节数。
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    常数字段值
- 构造方法详细信息
  - Long
```
@Deprecated(since="9")public Long(long value)
```
    Deprecated.
    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")public Long(String s)     throws NumberFormatException
```
    Deprecated.
    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对象，表示long由指示值String参数。该字符串parseLong方法用于基数10的方式完全转换为long值。
    
    参数
    
    s - String转换为 Long 。
    
    异常
    
    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 - 字符串表示形式中使用的基数。
    
    结果
    
    指定基数中参数的字符串表示形式。
    
    另请参见：
    
    Character.MAX_RADIX ， Character.MIN_RADIX
  - toUnsignedString
```
public static String toUnsignedString(long i,                                      int radix)
```
    返回第一个参数的字符串表示形式，作为第二个参数指定的基数中的无符号整数值。
    如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则使用基数10代替。
    
    请注意，由于第一个参数被视为无符号值，因此不会打印前导符号字符。
    
    如果幅度为零，则由单个零字符'0' （ '\u0030' ）表示; 否则，幅度表示的第一个字符将不是零字符。
    
    基数的行为和用作数字的字符与toString相同。
    
    参数
    
    i - 要转换为无符号字符串的整数。
    
    radix - 字符串表示中使用的基数。
    
    结果
    
    指定基数中参数的无符号字符串表示形式。
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    toString(long, int)
  - toHexString
```
public static String toHexString(long i)
```
    返回long参数的字符串表示形式，作为基数为16的无符号整数。
    如果参数为负， long符号long值为参数加2 ⁶⁴ ; 否则，它等于参数。此值将转换为十六进制（基数为16）的ASCII数字字符串，没有额外的前导0 。
    
    可以通过调用Long.parseUnsignedLong(s, 16)从返回的字符串s恢复参数的值。
    
    如果无符号幅度为零，则由单个零字符'0' （ '\u0030' ）表示; 否则，无符号幅度表示的第一个字符将不是零字符。以下字符用作十六进制数字：
    
    0123456789abcdef
    这些是字符'\u0030'至'\u0039'和'\u0061'至'\u0066' 。如果需要大写字母，可以在结果上调用String.toUpperCase()方法：
    Long.toHexString(n).toUpperCase()
    
    参数
    
    i - 要转换为字符串的 long 。
    
    结果
    
    由十六进制（基数为16）的参数表示的无符号 long值的字符串表示形式。
    
    从以下版本开始：
    
    1.0.2
    
    另请参见：
    
    parseUnsignedLong(String, int) ， toUnsignedString(long, int)
  - toOctalString
```
public static String toOctalString(long i)
```
    返回long参数的字符串表示形式，作为基数为8的无符号整数。
    如果参数为负， long符号long值为参数加2 ⁶⁴ ; 否则，它等于参数。此值将转换为八进制（基数为8）的ASCII数字字符串，没有额外的前导0 。
    
    可以通过调用Long.parseUnsignedLong(s, 8)从返回的字符串s恢复参数的值。
    
    如果无符号幅度为零，则由单个零字符'0' （ '\u0030' ）表示; 否则，无符号幅度表示的第一个字符将不是零字符。以下字符用作八进制数字：
    
    01234567
    这些是字符'\u0030'到'\u0037' 。
    
    参数
    
    i - 要转换为字符串的 long 。
    
    结果
    
    由八进制（基数8）中的参数表示的无符号 long值的字符串表示形式。
    
    从以下版本开始：
    
    1.0.2
    
    另请参见：
    
    parseUnsignedLong(String, int) ， toUnsignedString(long, int)
  - toBinaryString
```
public static String toBinaryString(long i)
```
    以基数2中的无符号整数形式返回long参数的字符串表示形式。
    如果参数为负， long符号long值为参数加2 ⁶⁴ ; 否则，它等于参数。此值将转换为二进制（基数2）中的ASCII数字字符串，没有额外的前导0 s。
    
    可以通过调用Long.parseUnsignedLong(s, 2)从返回的字符串s恢复参数的值。
    
    如果无符号幅度为零，则由单个零字符'0' （ '\u0030' ）表示; 否则，无符号幅度表示的第一个字符将不是零字符。字符'0' （ '\u0030' ）和'1' （ '\u0031' ）用作二进制数字。
    
    参数
    
    i - 要转换为字符串的 long 。
    
    结果
    
    由二进制（基数2）中的参数表示的无符号 long值的字符串表示形式。
    
    从以下版本开始：
    
    1.0.2
    
    另请参见：
    
    parseUnsignedLong(String, int) ， toUnsignedString(long, int)
  - 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
    
    另请参见：
    
    toUnsignedString(long, int)
  - 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参数作为有符号long指定radix ，在指定的开始beginIndex并延伸到endIndex - 1 。
    该方法不采取措施来防止CharSequence在解析时发生突变。
    
    参数
    
    s - CharSequence包含要解析的 long表示
    
    beginIndex - 起始索引，包括在内。
    
    endIndex - 结束索引，独占。
    
    radix - 解析 s使用的基数。
    
    结果
    
    签名的 long由指定基数中的子 long表示。
    
    异常
    
    NullPointerException - 如果 s为空。
    
    IndexOutOfBoundsException - 如果 beginIndex为负数，或者 beginIndex大于 endIndex或 endIndex大于 s.length() 。
    
    NumberFormatException - 如果 int在指定的 CharSequence中不包含可解析的 radix ，或者 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 -一个 String含有 long表示被解析
    
    结果
    
    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 ⁶⁴ -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参数为一个无符号long在指定的radix ，在指定的开始beginIndex并延伸到endIndex - 1 。
    该方法不会采取措施来防止CharSequence在解析时发生变异。
    
    参数
    
    s -所述 CharSequence含有无符号 long表示被解析
    
    beginIndex - 起始索引，包括在内。
    
    endIndex - 结束索引，独占。
    
    radix - 解析 s使用的基数。
    
    结果
    
    未 long由指定基数中的子 long表示。
    
    异常
    
    NullPointerException - 如果 s为空。
    
    IndexOutOfBoundsException - 如果 beginIndex为负数，或者 beginIndex大于 endIndex或者 endIndex大于 s.length() 。
    
    NumberFormatException - 如果 long在指定的 CharSequence中不包含可解析的无符号 radix ，或者 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 - 一个很长的价值。
    
    结果
    
    Long实例，代表 l 。
    
    从以下版本开始：
    
    1.5
  - decode
```
public static Long decode(String nm)                   throws NumberFormatException
```
    将String解码为Long 。接受以下语法给出的十进制，十六进制和八进制数：
    
    DecodableString:
    
    Sign_opt DecimalNumeral
    
    Sign_opt 0x HexDigits
    
    Sign_opt 0X HexDigits
    
    Sign_opt # HexDigits
    
    Sign_opt 0 OctalDigits
    
    Sign:
    
    -
    
    +
    
    DecimalNumeral ， HexDigits和OctalDigits在The Java™ Language Specification的 3.10.1节中定义，但数字之间不接受下划线。
    可选符号和/或基数说明符（“ 0x ”，“ 0X ”，“ # ”或前导零）后面的字符序列由Long.parseLong方法使用指示的基数（10,16或8）进行解析。此字符序列必须表示正值或将抛出NumberFormatException 。如果指定的String第一个字符是减号，则结果为否定。 String中不允许使用空格字符。
    
    参数
    
    nm - 要解码的 String 。
    
    结果
    
    Long持有 long值的对象，由 nm表示
    
    异常
    
    NumberFormatException - 如果 String不包含可分析的 long 。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    parseLong(String, int)
  - byteValue
```
public byte byteValue()
```
    返回此值 Long为 byte的基本收缩转换后。
    
    重写：
    
    byteValue类 Number
    
    结果
    
    转换为类型 byte后此对象表示的数值。
    
    See The Java™ Language Specification:
    
    5.1.3缩小原始转换
  - shortValue
```
public short shortValue()
```
    在缩小基元转换后，将此 Long的值作为 short返回。
    
    重写：
    
    shortValue类别 Number
    
    结果
    
    转换为类型 short后此对象表示的数值。
    
    See The Java™ Language Specification:
    
    5.1.3缩小原始转换
  - intValue
```
public int intValue()
```
    返回此的值 Long作为 int的基本收缩转换之后。
    
    Specified by:
    
    intValue类 Number
    
    结果
    
    转换为类型 int后此对象表示的数值。
    
    See The Java™ Language Specification:
    
    5.1.3缩小原始转换
  - longValue
```
public long longValue()
```
    以 long值的形式返回此 Long的值。
    
    Specified by:
    
    longValue在类 Number
    
    结果
    
    转换为类型 long后此对象表示的数值。
  - floatValue
```
public float floatValue()
```
    返回此值 Long为 float一个宽元转换后。
    
    Specified by:
    
    floatValue类 Number
    
    结果
    
    转换为类型 float后此对象表示的数值。
    
    See The Java™ Language Specification:
    
    5.1.2拓宽原始转换
  - doubleValue
```
public double doubleValue()
```
    返回此值 Long为 double一个宽元转换后。
    
    Specified by:
    
    doubleValue类 Number
    
    结果
    
    转换为类型 double后此对象表示的数值。
    
    See The Java™ Language Specification:
    
    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
    
    结果
    
    此对象的哈希码值。
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.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 。
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - getLong
```
public static Long getLong(String nm)
```
    确定具有指定名称的系统属性的long值。
    第一个参数被视为系统属性的名称。可以通过System.getProperty(java.lang.String)方法访问系统属性。然后此属性的字符串值被解释为long使用由支持的语法值decode和Long返回表示此值对象。
    
    如果没有具有指定名称的属性，如果指定的名称为空或null ，或者属性没有正确的数字格式，则返回null 。
    
    换句话说，此方法返回Long对象，其值等于：
    
    getLong(nm, null)
    
    参数
    
    nm - 房产名称。
    
    结果
    
    属性的 Long值。
    
    异常
    
    SecurityException - 原因与 System.getProperty相同
    
    另请参见：
    
    System.getProperty(java.lang.String) ， System.getProperty(java.lang.String, java.lang.String)
  - getLong
```
public static Long getLong(String nm,                           long val)
```
    确定具有指定名称的系统属性的long值。
    第一个参数被视为系统属性的名称。可以通过System.getProperty(java.lang.String)方法访问系统属性。然后此属性的字符串值被解释为long使用由支持的语法值decode和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价值 Long 。
    
    异常
    
    SecurityException - 原因与 System.getProperty相同
    
    另请参见：
    
    System.getProperty(java.lang.String) ， System.getProperty(java.lang.String, java.lang.String)
  - getLong
```
public static Long getLong(String nm,                           Long val)
```
    返回具有指定名称的系统属性的long值。第一个参数被视为系统属性的名称。可以通过System.getProperty(java.lang.String)方法访问系统属性。然后，根据decode方法将此属性的字符串值解释为long值，并返回表示此值的Long对象; 综上所述：
    
    如果属性值以两个ASCII字符0x或ASCII字符# ，后面没有减号，则其余部分将被解析为十六进制整数，与方法valueOf(java.lang.String, int)（带基数16）完全相同。
    
    如果属性值以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相同
    
    另请参见：
    
    System.getProperty(java.lang.String) ， System.getProperty(java.lang.String, java.lang.String)
  - compareTo
```
public int compareTo(Long anotherLong)
```
    以数字方式比较两个 Long对象。
    
    Specified by:
    
    compareTo ，界面 Comparable<Long>
    
    参数
    
    anotherLong - 待比较的 Long 。
    
    结果
    
    值0如果此Long是等于参数Long ; 的值小于0 ，如果这Long在数值上小于该参数Long ; 如果此Long在数值上大于参数Long （带符号的比较），则值大于0 。
    
    从以下版本开始：
    
    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 ; 小于0的值，如果x < y ; 和值大于0如果x > y
    
    从以下版本开始：
    
    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(long, long)
  - remainderUnsigned
```
public static long remainderUnsigned(long dividend,                                     long divisor)
```
    返回将第一个参数除以第二个参数的无符号余数，其中每个参数和结果都被解释为无符号值。
    
    参数
    
    dividend - 要划分的值
    
    divisor - 进行分割的价值
    
    结果
    
    第一个参数的无符号余数除以第二个参数
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    divideUnsigned(long, long)
  - 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：
    
    楼（log ₂ （x））= 63 - numberOfLeadingZeros(x)
    
    ceil（log ₂ （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值的二进制补码表示形式中的long 。此功能有时称为人口计数 。
    
    参数
    
    i - 要对其位进行计数的值
    
    结果
    
    指定的 long值的二进制补码二进制表示中的 long 。
    
    从以下版本开始：
    
    1.5
  - rotateLeft
```
public static long rotateLeft(long i,                              int distance)
```
    返回通过旋转指定long剩余的指定long值的二进制补码表达式获得的值。（位移出左侧，或高位，侧重新输入右侧，或低位。）
    请注意，具有负距离的左旋转等效于右旋转： rotateLeft(val, -distance) == rotateRight(val, distance) 。另请注意，按任意倍数64旋转是无操作，因此即使距离为负，也可以忽略旋转距离的最后六位以外的所有位： rotateLeft(val, distance) == rotateLeft(val, distance & 0x3F) 。
    
    参数
    
    i - 其位将向左旋转的值
    
    distance - 向左旋转的位位置数
    
    结果
    
    通过旋转指定 long剩余的指定 long值的二进制补码表达式获得的值。
    
    从以下版本开始：
    
    1.5
  - rotateRight
```
public static long rotateRight(long i,                               int distance)
```
    返回通过将指定的long值的二进制补码表示法旋转指定的long值。（位移出右手，或低位，侧面重新进入左侧，或高位。）
    请注意，具有负距离的右旋转等效于左旋转： rotateRight(val, -distance) == rotateLeft(val, distance) 。另请注意，按64的任意倍数旋转都是无操作，因此即使距离为负，也可以忽略旋转距离的最后六位以外的所有位： rotateRight(val, distance) == rotateRight(val, distance & 0x3F) 。
    
    参数
    
    i - 其位将向右旋转的值
    
    distance - 向右旋转的位位置数
    
    结果
    
    通过将指定的 long值的二进制补码二进制表示旋转指定的 long值。
    
    从以下版本开始：
    
    1.5
  - reverse
```
public static long reverse(long i)
```
    返回通过反转指定的 long值的二进制补码表达式中的位顺序获得的值。
    
    参数
    
    i - 要反转的值
    
    结果
    
    通过反转指定的 long值中的位顺序获得的值。
    
    从以下版本开始：
    
    1.5
  - signum
```
public static int signum(long i)
```
    返回指定的long值的signum函数。（如果指定的值为负，则返回值为-1;如果指定的值为零，则返回0;如果指定的值为正，则返回1。）
    
    参数
    
    i - 要计算其signum的值
    
    结果
    
    指定的 long值的signum函数。
    
    从以下版本开始：
    
    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
    
    另请参见：
    
    BinaryOperator
  - max
```
public static long max(long a,                       long b)
```
    返回两个 long值中较大的一个， long调用 Math.max一样。
    
    参数
    
    a - 第一个操作数
    
    b - 第二个操作数
    
    结果
    
    a和 b的较大者
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    BinaryOperator
  - min
```
public static long min(long a,                       long b)
```
    返回两个 long值中较小的一个， long调用 Math.min一样。
    
    参数
    
    a - 第一个操作数
    
    b - 第二个操作数
    
    结果
    
    较小的 a和 b
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    BinaryOperator

Class Long

字段汇总

构造方法摘要

方法摘要

声明方法的类 java.lang.Object

字段详细信息

MIN_VALUE

MAX_VALUE

TYPE

SIZE

BYTES

构造方法详细信息

Long

Long

方法详细信息

toString

toUnsignedString

toHexString

toOctalString

toBinaryString

toString

toUnsignedString

parseLong

parseLong

parseLong

parseUnsignedLong

parseUnsignedLong

parseUnsignedLong

valueOf

valueOf

valueOf

decode

byteValue

shortValue

intValue

longValue

floatValue

doubleValue

toString

hashCode

hashCode

equals

getLong

getLong

getLong

compareTo

compare

compareUnsigned

divideUnsigned

remainderUnsigned

highestOneBit

lowestOneBit

numberOfLeadingZeros

numberOfTrailingZeros

bitCount

rotateLeft

rotateRight

reverse

signum

reverseBytes

sum

max

min