模块 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

参见：

• Serialized Form

字段摘要

字段

修饰符和类型	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	compress(long i, long mask)	根据指定的位掩码，返回通过压缩指定的 long 值， i 的位获得的值。
static Long	decode(String nm)	将 String 解码为 Long 。
Optional<Long>	describeConstable()	返回一个 Optional ，其中包含此实例的标称描述符，即实例本身。
static long	divideUnsigned(long dividend, long divisor)	返回第一个参数除以第二个参数的无符号商，其中每个参数和结果都被解释为无符号值。
double	doubleValue()	在扩大原始转换后将此 Long 的值作为 double 返回。
boolean	equals(Object obj)	将此对象与指定对象进行比较。
static long	expand(long i, long mask)	根据指定的位掩码，返回通过扩展指定的 long 值， i 的位获得的值。
float	floatValue()	在扩大原始转换后将此 Long 的值作为 float 返回。
static Long	getLong(String nm)	确定具有指定名称的系统属性的 long 值。
static Long	getLong(String nm, long val)	确定具有指定名称的系统属性的 long 值。
static Long	getLong(String nm, Long val)	返回具有指定名称的系统属性的 long 值。
int	hashCode()	返回此 Long 的哈希码。
static int	hashCode(long value)	返回 long 值的哈希码；与 Long.hashCode() 兼容。
static long	highestOneBit(long i)	在指定的 long 值中最高位（“最左边”）一位的位置返回一个最多只有一位的 long 值。
int	intValue()	在缩小基元转换后将此 Long 的值作为 int 返回。
long	longValue()	将此 Long 的值作为 long 值返回。
static long	lowestOneBit(long i)	在指定的 long 值中最低位（“最右边”）一位的位置返回一个最多只有一位的 long 值。
static long	max(long a, long b)	返回两个 long 值中较大的一个，就像调用 Math.max 一样。
static long	min(long a, long b)	返回两个 long 值中较小的一个，就像通过调用 Math.min 一样。
static int	numberOfLeadingZeros(long i)	返回指定 long 值的二进制补码表示形式中最高阶（“最左边”）一位之前的零位数。
static int	numberOfTrailingZeros(long i)	返回指定 long 值的二进制补码表示形式中最低位（“最右边”）一位之后的零位数。
static long	parseLong(CharSequence s, int beginIndex, int endIndex, int radix)	将 CharSequence 参数解析为指定 radix 中的带符号 long，从指定的 beginIndex 开始并扩展到 endIndex - 1。
static long	parseLong(String s)	将字符串参数解析为带符号的十进制 long 。
static long	parseLong(String s, int radix)	将字符串参数解析为第二个参数指定的基数中带符号的 long。
static long	parseUnsignedLong(CharSequence s, int beginIndex, int endIndex, int radix)	将 CharSequence 参数解析为指定 radix 中的无符号 long，从指定的 beginIndex 开始并扩展到 endIndex - 1。
static long	parseUnsignedLong(String s)	将字符串参数解析为无符号十进制 long 。
static long	parseUnsignedLong(String s, int radix)	将字符串参数解析为第二个参数指定的基数中的无符号 long。
static long	remainderUnsigned(long dividend, long divisor)	返回第一个参数除以第二个参数的无符号余数，其中每个参数和结果都被解释为无符号值。
Long	resolveConstantDesc(MethodHandles.Lookup lookup)	将此实例解析为 ConstantDesc ，其结果是实例本身。
static long	reverse(long i)	返回通过反转指定 long 值的二进制补码表示中的位顺序获得的值。
static long	reverseBytes(long i)	返回通过反转指定 long 值的二进制补码表示中的字节顺序获得的值。
static long	rotateLeft(long i, int distance)	返回通过将指定的 long 值的二进制补码表示向左旋转指定位数而获得的值。
static long	rotateRight(long i, int distance)	返回通过将指定的 long 值的二进制补码表示向右旋转指定的位数而获得的值。
short	shortValue()	在缩小基元转换后将此 Long 的值作为 short 返回。
static int	signum(long i)	返回指定 long 值的符号函数。
static long	sum(long a, long b)	根据 + 运算符将两个 long 值相加。
static String	toBinaryString(long i)	将 long 参数的字符串表示形式返回为基数为 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 可以有，-2⁶³.

参见：

• 常量字段值

MAX_VALUE

@Native public static final long MAX_VALUE
            

一个保持最大值的常量 long 可以有，2⁶³-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 - 在字符串表示中使用的基数。

返回：

指定基数中参数的字符串表示形式。

参见：

• 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)
            

以 16 进制的无符号整数形式返回 long 参数的字符串表示形式。

无符号 long 值是参数加 2⁶⁴如果参数是否定的；否则，它等于参数。此值将转换为十六进制（基数 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

参见：

• HexFormat
• parseUnsignedLong(String, int)
• toUnsignedString(long, int)

toOctalString

public static String  toOctalString(long i)
            

将 long 参数的字符串表示形式返回为基数为 8 的无符号整数。

无符号 long 值是参数加 2⁶⁴如果参数是否定的；否则，它等于参数。此值将转换为八进制（基数 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⁶⁴如果参数是否定的；否则，它等于参数。此值将转换为二进制（基数为 2）的 ASCII 数字字符串，没有额外的前导 0 s。

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

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

参数：

i - 要转换为字符串的 long。

返回：

二进制参数表示的无符号 long 值的字符串表示形式（基数 2）。

自从：

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 参数解析为指定 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,2⁶⁴-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 对象，其值等于：

Long.valueOf(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 对象，其值等于：

Long.valueOf(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

参见：

• parseLong(String, int)

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 中

返回：

此对象的哈希码值。

参见：

• 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) 方法访问。然后使用 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 对象。

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

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

getLong(nm, Long.valueOf(val))

但实际上它可能以如下方式实现：

 Long result = getLong(nm, null);
 return (result == null) ? Long.valueOf(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) 方法访问。然后根据 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 相同

参见：

• System.getProperty(java.lang.String)
• System.getProperty(java.lang.String, java.lang.String)

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(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：

• 地板（日志₂(x)) = 63 - numberOfLeadingZeros(x)
• 天花板（日志₂(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

compress

public static long compress(long i, long mask)
            

根据指定的位掩码，返回通过压缩指定的 long 值， i 的位获得的值。

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

API 注意：

考虑压缩十六进制值的数字的简单情况：

// Compressing drink to food
compress(0xCAFEBABEL, 0xFF00FFF0L) == 0xCABABL
 

从右侧位置 0 处的最低有效十六进制数字开始，掩码 0xFF00FFF0 选择 0xCAFEBABE 位置 1、2、3、6 和 7 处的十六进制数字。所选数字以相同顺序从数字位置 0 连续出现在结果压缩值中。

以下身份都返回 true 并且有助于理解 compress 的行为：

// Returns 1 if the bit at position n is one
compress(x, 1L << n) == (x >> n & 1)

// Logical shift right
compress(x, -1L << n) == x >>> n

// Any bits not covered by the mask are ignored
compress(x, m) == compress(x & m, m)

// Compressing a value by itself
compress(m, m) == (m == -1 || m == 0) ? m : (1L << bitCount(m)) - 1

// Expanding then compressing with the same mask
compress(expand(x, m), m) == x & compress(m, m)
 

Sheep And Goats (SAG) 操作（参见 Hacker's Delight，第 7.7 节）可以按如下方式实现：

long compressLeft(long i, long mask) {
  // This implementation follows the description in Hacker's Delight which
  // is informative. A more optimal implementation is:
  //  Long.compress(i, mask) << -Long.bitCount(mask)
  return Long.reverse(
    Long.compress(Long.reverse(i), Long.reverse(mask)));
}

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

// Separate the sheep from the goats
sag(0x00000000_CAFEBABEL, 0xFFFFFFFF_FF00FFF0L) == 0x00000000_CABABFEEL
 

参数：

i - 要压缩其位的值

mask - 位掩码

返回：

压缩值

自从：

19

参见：

• expand(long, long)

expand

public static long expand(long i, long mask)
            

根据指定的位掩码，返回通过扩展指定的 long 值， i 的位获得的值。

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

API 注意：

考虑扩展十六进制值的数字的简单情况：

expand(0x0000CABABL, 0xFF00FFF0L) == 0xCA00BAB0L
 

从右侧位置 0 处的最低有效十六进制数字开始，掩码 0xFF00FFF0 选择 0x0000CABAB 的前五个十六进制数字。所选数字按顺序出现在结果扩展值中的位置 1、2、3、6 和 7。

以下身份都返回 true 并且有助于理解 expand 的行为：

// Logically shift right the bit at position 0
expand(x, 1L << n) == (x & 1) << n

// Logically shift right
expand(x, -1L << n) == x << n

// Expanding all bits returns the mask
expand(-1L, m) == m

// Any bits not covered by the mask are ignored
expand(x, m) == expand(x, m) & m

// Compressing then expanding with the same mask
expand(compress(x, m), m) == x & m
 

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

long select(long i, long n) {
  // the one-bit in i (the mask) with index n
  long nthBit = Long.expand(1L << n, i);
  // the bit position of the one-bit with index n
  return Long.numberOfTrailingZeros(nthBit);
}

// The one-bit with index 0 is at bit position 1
select(0b10101010_10101010, 0) == 1
// The one-bit with index 3 is at bit position 7
select(0b10101010_10101010, 3) == 7
 

参数：

i - 要扩展其位的值

mask - 位掩码

返回：

扩展值

自从：

19

参见：

• compress(long, long)

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

参见：

• 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

describeConstable

public Optional <Long > describeConstable()
            

返回一个 Optional ，其中包含此实例的标称描述符，即实例本身。

指定者：

describeConstable 在接口 Constable 中

返回：

Optional 描述了 Long 实例

自从：

12

resolveConstantDesc

public Long  resolveConstantDesc(MethodHandles.Lookup  lookup)
            

将此实例解析为 ConstantDesc ，其结果是实例本身。

指定者：

resolveConstantDesc 在接口 ConstantDesc 中

参数：

lookup - 忽略

返回：

Long 实例

自从：

12