Long (Java Platform SE 8 )

java.lang.Object
- java.lang.Number
- - java.lang.Long

All Implemented Interfaces:

Serializable Comparable Long >，<
```
public final class Long
extends Number
implements Comparable<Long>
```
这类包装 Long值对象中的原始类型 long。 Long类型的对象包含一个字段的类型是 long。
此外，该类提供了一个long转换到String和String到long的几种方法，以及其他的一些常量和方法可用于处理一个long。

实施说明：实施“点着”的方法（如highestOneBit和numberOfTrailingZeros）是基于材料从Henry S. Warren、Jr.的空高效程序的奥秘，（Addison Wesley，2002）。

从以下版本开始：

JDK1.0

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`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`代表原始类型的 `类`实例。

构造方法摘要

构造方法
Constructor and Description
`Long(long value)` 构建了一个新分配的 `Long`表示指定的 `long`论点。
`Long(String s)` 构建了一个新分配的 `Long`表示 `long`值表示的 `String`参数。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`static int`	`bitCount(long i)` 返回在二进制补码表示的指定 `long`值的比特数。
`byte`	`byteValue()` 作为一个窄化转换后 `byte`返回该 `Long`价值。
`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()` 为扩大基本转换后的 `double`返回该 `Long`价值。
`boolean`	`equals(Object obj)` 将此对象与指定的对象进行比较。
`float`	`floatValue()` 为扩大基本转换后的 `float`返回该 `Long`价值。
`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()` 作为一个窄化转换后， `int`返回该 `Long`价值。
`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(String s)` 将字符串参数作为一个符号的十进制 `long`。
`static long`	`parseLong(String s, int radix)` 将字符串参数作为 `long`签署由第二个参数指定的基数。
`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`值指定的位数左得到的值。
`static long`	`rotateRight(long i, int distance)` 返回值通过旋转的二进制补码表示的指定 `long`值指定的位数吧。
`short`	`shortValue()` 作为一个窄化转换后 `short`返回该 `Long`价值。
`static int`	`signum(long i)` 返回指定 `long`价值符号函数。
`static long`	`sum(long a, long b)` 增加了两 `long`值按运算符。
`static String`	`toBinaryString(long i)` 在基地 2无符号整数返回的 `long`参数的字符串表示。
`static String`	`toHexString(long i)` 在基地 16无符号整数返回的 `long`参数的字符串表示。
`static String`	`toOctalString(long i)` 在基地 8无符号整数返回的 `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)` 返回一个 `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

- Field Detail
  - MIN_VALUE
```
@Native
public static final long MIN_VALUE
```
    恒定保持最小值 long可以有，- 2 ^六十三。
    
    另请参见：
    
    Constant Field Values
  - MAX_VALUE
```
@Native
public static final long MAX_VALUE
```
    恒定保持最大值 long可以有，2 ^六十三-1。
    
    另请参见：
    
    Constant Field Values
  - TYPE
```
public static final 类<Long> TYPE
```
    long代表原始类型的 类实例。
    
    从以下版本开始：
    
    JDK1.1
  - SIZE
```
@Native
public static final int SIZE
```
    用于二进制补码形式表示 long值的比特数。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    Constant Field Values
  - BYTES
```
public static final int BYTES
```
    用于二进制补码形式表示 long值的字节数。
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    Constant Field Values
- Constructor Detail
  - Long
```
public Long(long value)
```
    构建了一个新分配的 Long表示指定的 long论点。
    
    参数
    
    value -被 Long对象表示的值。
  - Long
```
public Long(String s)
     throws NumberFormatException
```
    构建了一个新分配的 Long表示 long值表示的 String参数。字符串转换成完全由基数10 parseLong方法使用的方式 long价值。
    
    参数
    
    s - String被转换为 Long。
    
    异常
    
    NumberFormatException -如果 String不包含parsable long。
    
    另请参见：
    
    parseLong(java.lang.String, int)
- 方法详细信息
  - toString
```
public static String toString(long i,
                              int radix)
```
    返回由第二个参数指定的基数的第一个参数的字符串表示形式。
    如果基数小于或大于Character.MAX_RADIX Character.MIN_RADIX基数，然后10代替。
    
    如果第一个参数是负的，结果的第一个元素是ASCII减号'-'（'\u002d'）。如果第一个参数不是否定的，则不会出现在结果中出现的符号字符。
    
    结果的其余字符表示第一个参数的大小。如果值为零，它是由一个单一的零'0'代表（'\u0030'）；否则，对表示大小的第一个字符将不会是零。下面的ASCII字符作为数字：
    
    0123456789abcdefghijklmnopqrstuvwxyz
    这些 '\u0030'通过 '\u0039'和 '\u0061'通过 '\u007a'。如果 radix是 n，然后这些字符的第一 n作为radix- 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.MAX_RADIX Character.MIN_RADIX基数，然后10代替。
    
    请注意，由于第一个参数被视为一个无符号值，没有领先的符号字符被打印。
    
    如果值为零，它是由一个单一的零'0'代表（'\u0030'）；否则，对表示大小的第一个字符将不会是零。
    
    对根的行为和人物作为数字为toString相同。
    
    参数
    
    i -一个整数被转换为无符号的字符串。
    
    radix -中使用的进制的字符串表示形式。
    
    结果
    
    指定基数中的参数的无符号字符串表示形式。
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    toString(long, int)
  - toHexString
```
public static String toHexString(long i)
```
    在基地 16无符号整数返回的 long参数的字符串表示。
    无符号long值参数加2^六十四如果参数是负的；否则，它等于参数。这个值被转换成十六进制字符串ASCII数字（基地 16）没有额外的领导0s。
    
    这个参数的值可以从返回的字符串s通过调用Long.parseUnsignedLong(s, 16)恢复。
    
    如果无符号值为零，它是由一个单一的零'0'代表（'\u0030'）；否则，对符号数值表示的第一个字符不会是零。以下文字为十六进制数字：
    
    0123456789abcdef
    这些人物 '\u0030'通过 '\u0039'和 '\u0061'通过 '\u0066'。如果大写字母是理想的方法， String.toUpperCase()可以呼吁的结果：
    Long.toHexString(n).toUpperCase()
    
    参数
    
    i - long被转换为字符串。
    
    结果
    
    字符串表示的无符号 long值参数表示十六进制（基地 16）。
    
    从以下版本开始：
    
    JDK 1.0.2
    
    另请参见：
    
    parseUnsignedLong(String, int)， toUnsignedString(long, int)
  - toOctalString
```
public static String toOctalString(long i)
```
    在基地 8无符号整数返回的 long参数的字符串表示。
    无符号long值参数加2^六十四如果参数是负的；否则，它等于参数。这个值被转换成八进制字符串ASCII数字（基地 8）没有额外的领导0s。
    
    这个参数的值可以从返回的字符串s通过调用Long.parseUnsignedLong(s, 8)恢复。
    
    如果无符号值为零，它是由一个单一的零'0'代表（'\u0030'）；否则，对符号数值表示的第一个字符不会是零。以下字符作为八进制数字：
    
    01234567
    这些人物 '\u0030'通过 '\u0037'。
    
    参数
    
    i - long被转换为字符串。
    
    结果
    
    字符串表示的无符号 long价值的论点表示八进制（基地 8）。
    
    从以下版本开始：
    
    JDK 1.0.2
    
    另请参见：
    
    parseUnsignedLong(String, int)， toUnsignedString(long, int)
  - toBinaryString
```
public static String toBinaryString(long i)
```
    在基地 2无符号整数返回的 long参数的字符串表示。
    无符号long值参数加2^六十四如果参数是负的；否则，它等于参数。这个值转换为二进制字符串ASCII数字（基地 2）没有额外的领导0s。
    
    这个参数的值可以从返回的字符串s通过调用Long.parseUnsignedLong(s, 2)恢复。
    
    如果无符号值为零，它是由一个单一的零'0'代表（'\u0030'）；否则，对符号数值表示的第一个字符不会是零。人物'0'（'\u0030'）和'1'（'\u0031'）作为二进制数字。
    
    参数
    
    i - long被转换为字符串。
    
    结果
    
    字符串表示的无符号二进制 long值参数表示（基地 2）。
    
    从以下版本开始：
    
    JDK 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 -一个整数被转换为无符号的字符串。
    
    结果
    
    参数的无符号字符串表示形式。
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    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.MAX_RADIX Character.MIN_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含有 long表示要解析的 String。
    
    radix的基数是在分析 s使用。
    
    结果
    
    通过指定进制字符串表示的 long。
    
    异常
    
    NumberFormatException如果字符串不包含parsable long。
  - 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如果字符串不包含parsable long。
  - parseUnsignedLong
```
public static long parseUnsignedLong(String s,
                                     int radix)
                              throws NumberFormatException
```
    将字符串参数作为进制由第二个参数指定一个无符号 long。一个无符号整数映射到正数大于负数的值通常 MAX_VALUE。字符串中的字符必须是指定的小数位数（确定是否 Character.digit(char, int)返回非负价值），除了第一个字符可以是ASCII加号 '+'（ '\u002B'）。将得到的整数值返回。
    如果出现下列情况时抛出的异常类型是NumberFormatException：
    - 第一个参数是null或是字符串的长度为零。
    - 基数是小于或大于Character.MAX_RADIX Character.MIN_RADIX。
    - 任何字符的字符串不指定进制的数字，除了第一个字符可能是一个加号'+'（'\u002B'）提供的字符串长度大于1。
    - 字符串表示的值大于最大无符号long，2^六十四-1。
    参数
    
    s -含无符号整数表示要解析的 String
    
    radix的基数是在分析 s使用。
    
    结果
    
    通过指定进制字符串参数表示的无符号 long。
    
    异常
    
    NumberFormatException -如果 String不包含parsable long。
    
    从以下版本开始：
    
    一点八
  - parseUnsignedLong
```
public static long parseUnsignedLong(String s)
                              throws NumberFormatException
```
    将字符串参数为一个无符号十进制 long。字符串中的字符都必须是十进制数字，除了第一个字符可能是一个ASCII加号 '+'（ '\u002B'）。由此产生的整数的值被返回，就像争论和基数为10得到的 parseUnsignedLong(java.lang.String, int)方法参数。
    
    参数
    
    s - String包含符号 long表示被解析
    
    结果
    
    由十进制字符串参数表示的无符号 long价值
    
    异常
    
    NumberFormatException如果字符串不包含parsable无符号整数。
    
    从以下版本开始：
    
    一点八
  - 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不包含parsable 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)，这种方法可能会产生显着更好的空间和时间，通过缓存经常请求的价值表现。值得注意的是，不同于 Integer班 corresponding method，这种方法不需要缓存的值在一个特定的范围。
    
    参数
    
    l -长值。
    
    结果
    
    一个代表 l Long实例。
    
    从以下版本开始：
    
    一点五
  - 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:
    
    -
    
    +
    
    nulldecimalnumeral，nullhexdigits，和nulloctaldigits是在 The Java™ Language Specification第3.10.1定义，除了强调不接受之间的数字。
    的字符序列遵循一个可选的标志和/或基数符（“0x”、“0X”、“#”，或前导零）解析与显示的基数Long.parseLong法（10，16，或8）。这个序列的字符必须是一个积极的价值或NumberFormatException将抛出。结果是否定，如果指定的第一个字符是String负号。没有空格字符是在String允许。
    
    参数
    
    nm - String解码。
    
    结果
    
    一个 Long对象持有 long所代表的价值 nm
    
    异常
    
    NumberFormatException -如果 String不包含parsable long。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    parseLong(String, int)
  - byteValue
```
public byte byteValue()
```
    作为一个窄化转换后 byte返回该 Long价值。
    
    重写：
    
    byteValue 方法重写，继承类 Number
    
    结果
    
    这代表的对象转换为数值型 byte后。
    
    See The Java™ Language Specification:
    
    5.1.3缩小原始转换
  - shortValue
```
public short shortValue()
```
    作为一个窄化转换后 short返回该 Long价值。
    
    重写：
    
    shortValue 方法重写，继承类 Number
    
    结果
    
    这代表的对象转换为数值型 short后。
    
    See The Java™ Language Specification:
    
    5.1.3缩小原始转换
  - intValue
```
public int intValue()
```
    作为一个窄化转换后， int返回该 Long价值。
    
    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()
```
    为扩大基本转换后的 float返回该 Long价值。
    
    Specified by:
    
    floatValue 方法重写，继承类 Number
    
    结果
    
    这代表的对象转换为数值型 float后。
    
    See The Java™ Language Specification:
    
    5.1.2扩大原始转换
  - doubleValue
```
public double doubleValue()
```
    为扩大基本转换后的 double返回该 Long价值。
    
    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值的哈希码值。
    
    从以下版本开始：
    
    一点八
  - 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)方法。此属性的字符串值，则解释为使用decode和代表这个值Long对象支持的语法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)方法。此属性的字符串值，则解释为使用decode和代表这个值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价值。
    
    异常
    
    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价值。
    
    异常
    
    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（签署的比较）。
    
    从以下版本开始：
    
    一点二
  - compare
```
public static int compare(long x,
                          long y)
```
    比较两 long值的数值。返回的值是什么将返回相同的：
```
长。值（x）。CompareTo（长。值（Y））
```
    参数
    
    x -比较第一 long
    
    y -比较二 long
    
    结果
    
    价值 0如果 x == y；值小于 0如果 x < y；和一个值大于 0如果 x > y
    
    从以下版本开始：
    
    一点七
  - compareUnsigned
```
public static int compareUnsigned(long x,
                                  long y)
```
    比较两 long值数值处理的值为无符号。
    
    参数
    
    x -比较第一 long
    
    y -比较二 long
    
    结果
    
    价值 0如果 x == y；值小于 0如果 x < y作为无符号值；和值大于 0如果 x > y作为无符号值
    
    从以下版本开始：
    
    一点八
  - divideUnsigned
```
public static long divideUnsigned(long dividend,
                                  long divisor)
```
    返回将第一个参数除以每个参数的第二个值的无符号商，并将结果解释为一个无符号值。
    请注意，在两个补充算法中，三个其他基本的算术运算的加，减，乘是位明智的相同，如果两个操作数被视为都被签署或都是无符号。因此，单独的addUnsigned，不提供方法。
    
    参数
    
    dividend -分的价值
    
    divisor价值-做划分
    
    结果
    
    由第二个参数分隔的第一个参数的无符号商
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    remainderUnsigned(long, long)
  - remainderUnsigned
```
public static long remainderUnsigned(long dividend,
                                     long divisor)
```
    返回由第二个在每个参数和结果被解释为一个无符号值的第二个分区的第一个参数的无符号的剩余部分。
    
    参数
    
    dividend -分的价值
    
    divisor价值-做划分
    
    结果
    
    由第二个参数分隔的第一个参数的无符号的其余部分
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    divideUnsigned(long, long)
  - highestOneBit
```
public static long highestOneBit(long i)
```
    返回一个 long值在一个单一的一个点，在最高的位置（“左”）在指定 long价值一点。返回零，如果指定的值在它的两个二进制表示中没有一个位，即，如果它等于零。
    
    参数
    
    i的最高的一点是要计算的值
    
    结果
    
    一个单一的一位 long价值，在最高的一个点的位置在指定的值，或零，如果指定的值是等于零。
    
    从以下版本开始：
    
    一点五
  - lowestOneBit
```
public static long lowestOneBit(long i)
```
    返回一个 long值在一个单一的一个点，在最低阶的位置（“右”）在指定 long价值一点。返回零，如果指定的值在它的两个二进制表示中没有一个位，即，如果它等于零。
    
    参数
    
    i的最低的一点是要计算的值
    
    结果
    
    一个单一的一位 long值，在最低阶位的位置在指定的值，或零，如果指定的值是等于零。
    
    从以下版本开始：
    
    一点五
  - numberOfLeadingZeros
```
public static int numberOfLeadingZeros(long i)
```
    返回零位前最高阶数（“左”）的二进制补码表示的指定 long价值一点。返回64如果指定的值没有一个位在它的两个的补充表示，在其他的话，如果它等于零。
    请注意，这种方法是密切相关的对数基数2。所有积极的long值x：
    - 楼（log_二（x））= 63 - numberOfLeadingZeros(x)
    - 细胞（log_二（x））= 64 - numberOfLeadingZeros(x - 1)
    参数
    
    i -前导零的数量被计算的价值
    
    结果
    
    零位前最高阶数（“左”）的二进制补码表示的指定 long价值一点，或64，如果该值等于零。
    
    从以下版本开始：
    
    一点五
  - numberOfTrailingZeros
```
public static int numberOfTrailingZeros(long i)
```
    返回零位以下的最低阶数（“右”）在二进制补码表示的指定 long价值一点。返回64如果指定的值没有一个位在它的两个的补充表示，在其他的话，如果它等于零。
    
    参数
    
    i的一些尾随零是要计算的值
    
    结果
    
    以下的最低阶零比特数（“右”）在二进制补码表示的指定 long价值一点，或64，如果该值等于零。
    
    从以下版本开始：
    
    一点五
  - bitCount
```
public static int bitCount(long i)
```
    返回在二进制补码表示的指定 long值的比特数。此功能有时被称为零人口统计。
    
    参数
    
    i的比特被统计值
    
    结果
    
    在二进制补码表示的指定 long值的比特数。
    
    从以下版本开始：
    
    一点五
  - rotateLeft
```
public static long rotateLeft(long i,
                              int distance)
```
    返回通过旋转的二进制补码表示的指定 long值指定的位数左得到的值。（比特转移出来的左手，或高阶，侧进入的权利，或低阶
    注意左旋转与负面的距离相当于右旋转：rotateLeft(val, -distance) == rotateRight(val, distance)。注意，任何64的倍数旋转是一种没有OP，所以所有的旋转距离最后六位是可以忽略的，即使是负面的：rotateLeft(val, distance) == rotateLeft(val, distance & 0x3F)距离。
    。）
    
    参数
    
    i的位是向左的价值
    
    distance -位数向左旋转
    
    结果
    
    通过旋转的二进制补码表示的指定 long值指定的位数左得到的值。
    
    从以下版本开始：
    
    一点五
  - rotateRight
```
public static long rotateRight(long i,
                               int distance)
```
    返回值通过旋转的二进制补码表示的指定 long值指定的位数吧。（位转向了右边，或低阶，一边重新输入在左边，或高阶
    注意，用负距离右旋转相当于左旋转：rotateRight(val, -distance) == rotateLeft(val, distance)。还请注意，任何64的倍数旋转是一种没有OP，所以所有的旋转距离最后六位是可以忽略的，即使是负面的：rotateRight(val, distance) == rotateRight(val, distance & 0x3F)距离。
    。）
    
    参数
    
    i的比特被旋转权价值
    
    distance -位数向右旋转
    
    结果
    
    得到的值通过旋转的二进制补码表示的指定 long值指定的位数吧。
    
    从以下版本开始：
    
    一点五
  - reverse
```
public static long reverse(long i)
```
    返回通过逆转的二进制补码表示的指定 long值的比特顺序得到的值。
    
    参数
    
    i -被扭转的价值
    
    结果
    
    通过颠倒秩序的钻头在指定的 long值获得的价值。
    
    从以下版本开始：
    
    一点五
  - signum
```
public static int signum(long i)
```
    返回指定 long价值符号函数。（返回值为- 1，如果指定的值为负；0，如果指定的值为零；和1，如果指定的值是积极的。）
    
    参数
    
    i的符号是要计算的值
    
    结果
    
    指定的 long价值符号函数。
    
    从以下版本开始：
    
    一点五
  - reverseBytes
```
public static long reverseBytes(long i)
```
    返回通过逆转的二的补码表示指定的 long值的字节的顺序得到的值。
    
    参数
    
    i的字节被扭转的价值
    
    结果
    
    通过反转字节指定 long值获得的价值。
    
    从以下版本开始：
    
    一点五
  - sum
```
public static long sum(long a,
                       long b)
```
    增加了两 long值按运算符。
    
    参数
    
    a -第一个操作数
    
    b -第二个操作数
    
    结果
    
    a和 b的总和
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    BinaryOperator
  - max
```
public static long max(long a,
                       long b)
```
    返回大两 long值如果通过调用 Math.max。
    
    参数
    
    a -第一个操作数
    
    b -第二个操作数
    
    结果
    
    对 a和 b大
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    BinaryOperator
  - min
```
public static long min(long a,
                       long b)
```
    返回小两 long值如果通过调用 Math.min。
    
    参数
    
    a -第一个操作数
    
    b -第二个操作数
    
    结果
    
    对 a和 b较小
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    BinaryOperator

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class Long

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Field Detail

MIN_VALUE

MAX_VALUE

TYPE

SIZE

BYTES

Constructor Detail

Long

Long

方法详细信息

toString

toUnsignedString

toHexString

toOctalString

toBinaryString

toString

toUnsignedString

parseLong

parseLong

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