All Implemented Interfaces:

Serializable ， Comparable<Long>
```
public final class Long
extends Number
implements 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

Field Summary

Fields
Modifier and Type	Field	描述
`static int`	`BYTES`	用于表示二进制补码二进制形式的 `long`值的字节数。
`static long`	`MAX_VALUE`	一个持有最大值的常数a `long`可以有2 ⁶³ -1。
`static long`	`MIN_VALUE`	的常量保持的最小值的 `long`可以具有-2 ^63。
`static int`	`SIZE`	用于表示二进制补码二进制形式的 `long`值的位数。
`static Class<Long>`	`TYPE`	所述 `Class`实例表示基本类型 `long` 。

构造方法摘要

构造方法
Constructor	描述
`Long(long value)`	已过时。很少使用这个构造函数。静态工厂`valueOf(long)`通常是一个更好的选择，因为它可能产生明显更好的空间和时间性能。
`Long(String s)`	已过时。很少使用这个构造函数。使用`parseLong(String)`将字符串转换为`long`原语，或使用`valueOf(String)`将字符串转换为`Long`对象。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	方法	描述
`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`值中，最高位（最左边）为1位，最多返回一个 `long`值，最多只有一个1位。
`int`	`intValue()`	在缩小的原始转换后，返回 `Long`的值作为 `int` 。
`long`	`longValue()`	返回此值 `Long`为 `long`值。
`static long`	`lowestOneBit(long i)`	在指定的 `long`值中以最低位（最右边）为1位返回一个 `long`值，最多只有一个1位。
`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`值的二进制补码二进制表示中最高位（“最左”）1位之前的零位数。
`static int`	`numberOfTrailingZeros(long i)`	返回在指定的 `long`值的二进制补码二进制表示中的最低位（“最右”）1位之后的零位数。
`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`值添加 `long`一起。
`static String`	`toBinaryString(long i)`	返回 `long`参数的字符串表示形式为基数2中的无符号整数。
`static String`	`toHexString(long i)`	返回 `long`参数的字符串表示形式，作为16位中的无符号整数。
`static String`	`toOctalString(long i)`	在基数8中返回 `long`参数的字符串表示形式为无符号整数。
`String`	`toString()`	返回一个表示 `Long`的值的 `String`对象。
`static String`	`toString(long i)`	返回 `String`表示指定对象 `long` 。
`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`提取的值，并使用第二个参数给出的基数进行解析。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 字段详细信息
  - MIN_VALUE
```
@Native
public static final long MIN_VALUE
```
    的常量保持的最小值的 long可以具有-2 ^63。
    
    另请参见：
    
    Constant Field Values
  - MAX_VALUE
```
@Native
public static final long MAX_VALUE
```
    一个持有最大值a的常数a long可以有2 ⁶³ -1。
    
    另请参见：
    
    Constant Field Values
  - TYPE
```
public static final Class<Long> TYPE
```
    所述 Class实例表示基本类型 long 。
    
    从以下版本开始：
    
    1.1
  - SIZE
```
@Native
public static final int SIZE
```
    用于表示二进制补码二进制形式的 long值的位数。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    Constant Field Values
  - BYTES
```
public static final int BYTES
```
    用于表示二进制补码二进制形式的 long值的字节数。
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    Constant Field Values
- 构造方法详细信息
  - Long
```
@Deprecated(since="9")
public Long(long value)
```
    已过时。很少使用这个构造函数。静态工厂valueOf(long)通常是更好的选择，因为它可能产生明显更好的空间和时间性能。
    
    构造一个新分配的 Long对象，该对象表示指定的 long参数。
    
    参数
    
    value - 要由 Long对象表示的值。
  - Long
```
@Deprecated(since="9")
public Long(String s)
     throws NumberFormatException
```
    已过时。很少使用这个构造函数。使用parseLong(String)将字符串转换为long原语，或使用valueOf(String)将字符串转换为Long对象。
    
    构造一个新分配的Long对象，表示由String参数指示的long值。字符串转换为long值，正好与基数为parseLong方法一样。
    
    参数
    
    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位。因此，十六进制（ 0123456789abcdef 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值是参数加上2 ^64，如果参数为负数; 否则，它等于论证。该值转换为十六进制（基数16）的ASCII数字字符串，无额外引导0 s。
    
    可以通过调用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)
```
    在基数8中返回long参数的字符串表示形式为无符号整数。
    无符号的long值是参数加上2 ^64，如果参数为负数; 否则，它等于论证。该值转换为八进制（基数8）中的ASCII数字字符串，没有额外的前导0 s。
    
    可以通过调用Long.parseUnsignedLong(s, 8)从返回的字符串s恢复参数的值。
    
    如果无符号幅度为零，则由单个零字符'0' （ '\u0030' ）表示; 否则，无符号大小的表示的第一个字符将不是零字符。以下字符用作八进制数字：
    
    01234567
    这些是'\u0030'至'\u0037' 。
    
    参数
    
    i - 一个 long要转换成一个字符串。
    
    结果
    
    由参数以八进制表示的无符号 long值的字符串表示（基数8）。
    
    从以下版本开始：
    
    1.0.2
    
    另请参见：
    
    parseUnsignedLong(String, int) ， toUnsignedString(long, int)
  - toBinaryString
```
public static String toBinaryString(long i)
```
    返回long参数的字符串表示形式为基数2中的无符号整数。
    无符号的long值是参数加上2 ^64，如果参数为负数; 否则，它等于论证。该值转换为二进制（基数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)
```
    返回String表示指定对象long 。参数被转换为带符号的十进制表示形式，并作为字符串返回，就好像参数和基数10作为toString(long, int)方法的参数。
    
    参数
    
    i - a 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 （ '\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 （ '\u004C' ）以及l （ '\u006C' ）都不允许作为类型指示符出现在字符串的末尾，如在Java编程语言源代码中允许的那样。
    
    参数
    
    s - a 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 - a String其中包含要解析的无符号 long表示
    
    结果
    
    无符号的 long值由十进制字符串参数表示
    
    异常
    
    NumberFormatException - 如果字符串不包含可分析的无符号整数。
    
    从以下版本开始：
    
    1.8
  - valueOf
```
public static Long valueOf(String s,
                           int radix)
                    throws NumberFormatException
```
    当使用第二个参数给出的基数进行解析时，返回一个保存从指定的String提取的值的Long对象。第一个参数被解释为表示由第二个参数指定的基数中的带符号的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对象保存由string参数表示的值。
    
    异常
    
    NumberFormatException - 如果字符串不能被解析为 long 。
  - valueOf
```
public static Long valueOf(long l)
```
    返回表示指定的long值的Long实例。如果不需要新的Long实例，则该方法通常应优先于构造函数Long(long)使用，因为该方法可能通过缓存经常请求的值而产生明显更好的空间和时间性能。请注意，与corresponding method在Integer类，这种方法不需要缓存值的特定范围内。
    
    参数
    
    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）的Long.parseLong方法进行解析。这个字符序列必须表示正值，或者将抛出一个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的两半的异或。也就是说，hashcode是表达式的值：
    (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)
```
    将此对象与指定的对象进行比较。如果且仅当参数不是null并且是包含与此对象相同的long值的Long对象时，结果为true 。
    
    重写：
    
    equals在 Object
    
    参数
    
    obj - 要比较的对象。
    
    结果
    
    true如果对象是一样的; false否则。
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - getLong
```
public static Long getLong(String nm)
```
    确定具有指定名称的系统属性的值为long 。
    第一个参数被视为系统属性的名称。系统属性可通过System.getProperty(java.lang.String)方法访问。然后，使用long支持的语法将该属性的字符串值解释为long，并返回表示此值的Long对象。
    
    如果没有指定名称的属性，如果指定的名称为空或null ，或者该属性没有正确的数字格式，则返回null 。
    
    换句话说，该方法返回一个Long对象的值等于：
    
    getLong(nm, null)
    
    参数
    
    nm - 属性名称。
    
    结果
    
    该 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)方法访问。然后，使用long支持的语法将该属性的字符串值解释为long，并返回表示此值的Long对象。
    
    第二个参数是默认值。如果没有指定名称的属性，如果该属性没有正确的数字格式，或者指定的名称为空或为空，则返回表示第二个参数的值的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)方法访问。然后将该属性的字符串值解释为long值，按照decode方法，并返回表示此值的Long对象; 综上所述：
    
    如果属性值以两个ASCII字符0x或ASCII字符# ，而不是后跟减号，则其余部分将被解析为与基数16的方法valueOf(java.lang.String, int)完全一致的十六进制整数。
    
    如果属性值以ASCII字符0后跟另一个字符开头，则将其解析为与基数8的方法valueOf(java.lang.String, int)完全一致的八进制整数。
    
    否则，属性值将被解析为十进制整数，与使用基数10的方法valueOf(java.lang.String, int)完全相同。
    
    注意，在每种情况下， L （ '\u004C' ）和l （ '\u006C' ）作为类型指示符出现在属性值的末尾，如Java编程语言源代码中允许的那样。
    
    第二个参数是默认值。如果没有指定名称的属性，如果该属性没有正确的数字格式，或者指定的名称为空，则返回默认值，或者是null 。
    参数
    
    nm - 属性名称。
    
    val - 默认值。
    
    结果
    
    该 Long价值 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 ; 和大于一个值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 ; 一个值小于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 ; 一个值小于0如果x < y为无符号值; 并且如果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值至多一个单个1位，在最高阶（“最左侧”）的位置在指定的一比特long值。如果指定的值在其二进制补码二进制表示中没有1位，也就是说，如果它等于零，则返回零。
    
    参数
    
    i - 要计算其最高一位的值
    
    结果
    
    具有单个1位的 long值，在指定值中的最高位1位的位置，如果指定的值本身等于零，则为零。
    
    从以下版本开始：
    
    1.5
  - lowestOneBit
```
public static long lowestOneBit(long i)
```
    在指定的long值中以最低位（最右）的位置返回long值，最多只有一个1位。如果指定的值在其二进制补码二进制表示中没有1位，也就是说，如果它等于零，则返回零。
    
    参数
    
    i - 要计算最低一位的值
    
    结果
    
    具有单个1位的 long值，在指定值中的最低位1位的位置，如果指定的值本身等于零，则为零。
    
    从以下版本开始：
    
    1.5
  - numberOfLeadingZeros
```
public static int numberOfLeadingZeros(long i)
```
    返回指定的long值的二进制补码二进制表示中最高位（“最左”）1位之前的零位数。如果指定的值在其二进制补码表示中没有一位，换句话说如果它等于零则返回64。
    请注意，该方法与对数基数2密切相关。对于所有正值long值x：
    
    floor（log ₂ （x））= 63 - numberOfLeadingZeros(x)
    
    ceil（log ₂ （x））= 64 - numberOfLeadingZeros(x - 1)
    参数
    
    i - 要计算前导零数的值
    
    结果
    
    在指定的 long值的二进制补码二进制表示中的最高位（“最左”）1位之前的零位数，如果该值等于零，则为64。
    
    从以下版本开始：
    
    1.5
  - numberOfTrailingZeros
```
public static int numberOfTrailingZeros(long i)
```
    返回在指定的long值的二进制补码二进制表示中的最低位（“最右”）1位之后的零位数。如果指定的值在其二进制补码表示中没有一位，换句话说如果它等于零则返回64。
    
    参数
    
    i - 要计算尾数零的值
    
    结果
    
    在指定的 long值的二进制补码二进制表示中的最低位（“最右”）1位后的零位数，如果该值等于零，则为64位。
    
    从以下版本开始：
    
    1.5
  - bitCount
```
public static int bitCount(long i)
```
    返回指定的long值的二进制补码二进制表示中的long 。此功能有时称为人口数量 。
    
    参数
    
    i - 要对其位进行计数的值
    
    结果
    
    二进制数的二进制补码二进制表示为指定的 long值。
    
    从以下版本开始：
    
    1.5
  - rotateLeft
```
public static long rotateLeft(long i,
                              int distance)
```
    返回通过将指定的long值的二进制补码二进制表示旋转指定的long值。（左侧移位的位或右侧的高位侧重新输入，或低位）。
    请注意，具有负距离的左旋转相当于右旋： rotateLeft(val, -distance) == rotateRight(val, distance) 。由64多个任何还需要注意的是旋转是一个空操作，所以所有，但旋转距离的后6位可以忽略，即使距离为负： 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 - 要计算其符号的值
    
    结果
    
    指定功能的指定值为 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
    
    另请参见：
    
    BinaryOperator
  - max
```
public static long max(long a,
                       long b)
```
    返回两个 long值中的较大值，如同通过调用 Math.max一样。
    
    参数
    
    a - 第一个操作数
    
    b - 第二个操作数
    
    结果
    
    较大的 a和 b
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    BinaryOperator
  - min
```
public static long min(long a,
                       long b)
```
    返回两个 long中的较小值，就像调用 Math.min一样。
    
    参数
    
    a - 第一个操作数
    
    b - 第二个操作数
    
    结果
    
    较小的 a和 b
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    BinaryOperator

Class Long

Field Summary

构造方法摘要

方法摘要

Methods inherited from class 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