模块 java.base

包 java.lang

类 Integer

java.lang.Object

java.lang.Number

java.lang.Integer

所有已实现的接口：

Serializable , Comparable<Integer> , Constable , ConstantDesc

public final class Integer extends Number implements Comparable <Integer >, Constable , ConstantDesc 
      

Integer 类将原始类型 int 的值包装在一个对象中。 Integer 类型的对象包含一个类型为 int 的字段。

此外，此类提供了几种将 int 转换为 String 和将 String 转换为 int 的方法，以及在处理 int 时有用的其他常量和方法。

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

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

自从：

1.0

参见：

• Serialized Form

字段摘要

字段

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

构造方法总结

构造方法

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

方法总结

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

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

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

字段详细信息

MIN_VALUE

@Native public static final int MIN_VALUE
            

保持 int 可以具有的最小值的常数，-2³¹.

参见：

• 常量字段值

MAX_VALUE

@Native public static final int MAX_VALUE
            

保持 int 可以具有的最大值的常数，2³¹-1.

参见：

• 常量字段值

TYPE

public static final Class <Integer > TYPE
            

代表原始类型 int 的 Class 实例。

自从：

1.1

SIZE

@Native public static final int SIZE
            

用于以二进制补码形式表示 int 值的位数。

自从：

1.5

参见：

• 常量字段值

BYTES

public static final int BYTES
            

用于以二进制补码形式表示 int 值的字节数。

自从：

1.8

参见：

• 常量字段值

构造方法详细信息

Integer

@Deprecated (since ="9", forRemoval =true) public Integer(int value)
            

已弃用，将被删除：此 API 元素可能会在未来版本中删除。

使用此构造函数很少是合适的。静态工厂 valueOf(int) 通常是更好的选择，因为它可能会产生更好的空间和时间性能。

构造一个新分配的 Integer 对象，表示指定的 int 值。

参数：

value - Integer 对象要表示的值。

Integer

@Deprecated (since ="9", forRemoval =true) public Integer(String  s) throws NumberFormatException 
            

已弃用，将被删除：此 API 元素可能会在未来版本中删除。

使用此构造函数很少是合适的。使用 parseInt(String) 将字符串转换为 int 基元，或使用 valueOf(String) 将字符串转换为 Integer 对象。

构造一个新分配的 Integer 对象，该对象表示 String 参数指示的 int 值。字符串转换为 int 值的方式与 parseInt 方法用于基数 10 的方式完全相同。

参数：

s - 要转换为 Integer 的 String。

抛出：

NumberFormatException - 如果 String 不包含可解析的整数。

方法详情

toString

public static String  toString(int 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() 方法：

Integer.toString(n, 16).toUpperCase()

参数：

i - 要转换为字符串的整数。

radix - 在字符串表示中使用的基数。

返回：

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

参见：

• Character.MAX_RADIX
• Character.MIN_RADIX

toUnsignedString

public static String  toUnsignedString(int i, int radix)
            

返回第一个参数的字符串表示形式，作为第二个参数指定的基数中的无符号整数值。

如果基数小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX ，则改用基数 10。

请注意，由于第一个参数被视为无符号值，因此不会打印前导符号字符。

如果幅度为零，则由单个零字符 '0' ('\u0030' ) 表示；否则，幅度表示的第一个字符将不是零字符。

基数的行为和用作数字的字符与 toString 相同。

参数：

i - 要转换为无符号字符串的整数。

radix - 在字符串表示中使用的基数。

返回：

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

自从：

1.8

参见：

• toString(int, int)

toHexString

public static String  toHexString(int i)
            

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

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

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

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

0123456789abcdef

这些是字符 '\u0030' 到 '\u0039' 和 '\u0061' 到 '\u0066' 。如果需要大写字母，可以对结果调用 String.toUpperCase() 方法：

Integer.toHexString(n).toUpperCase()

API 注意：

HexFormat 类提供字节数组和原语的格式化和解析以返回字符串或添加到 Appendable 。 HexFormat 格式化和解析大写或小写十六进制字符，前导零和字节数组包括每个字节的分隔符、前缀和后缀。

参数：

i - 要转换为字符串的整数。

返回：

参数以十六进制（基数 16）表示的无符号整数值的字符串表示形式。

自从：

1.0.2

参见：

• HexFormat
• parseUnsignedInt(String, int)
• toUnsignedString(int, int)

toOctalString

public static String  toOctalString(int i)
            

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

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

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

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

01234567

这些是字符 '\u0030' 到 '\u0037' 。

参数：

i - 要转换为字符串的整数。

返回：

参数以八进制（基数 8）表示的无符号整数值的字符串表示形式。

自从：

1.0.2

参见：

• parseUnsignedInt(String, int)
• toUnsignedString(int, int)

toBinaryString

public static String  toBinaryString(int i)
            

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

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

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

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

参数：

i - 要转换为字符串的整数。

返回：

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

自从：

1.0.2

参见：

• parseUnsignedInt(String, int)
• toUnsignedString(int, int)

toString

public static String  toString(int i)
            

返回表示指定整数的 String 对象。参数被转换为带符号的十进制表示形式并作为字符串返回，就像参数和基数 10 作为参数提供给 toString(int, int) 方法一样。

参数：

i - 要转换的整数。

返回：

以 10 为基数的参数的字符串表示形式。

toUnsignedString

public static String  toUnsignedString(int i)
            

将参数的字符串表示形式返回为无符号十进制值。该参数被转换为无符号十进制表示形式，并作为字符串返回，就像将参数和基数 10 作为参数提供给 toUnsignedString(int, int) 方法一样。

参数：

i - 要转换为无符号字符串的整数。

返回：

参数的无符号字符串表示。

自从：

1.8

参见：

• toUnsignedString(int, int)

parseInt

public static int parseInt(String  s, int radix) throws NumberFormatException 
            

将字符串参数解析为第二个参数指定的基数中的有符号整数。字符串中的字符必须都是指定基数的数字（由 Character.digit(char, int) 是否返回非负值决定），除了第一个字符可以是 ASCII 减号 '-' ('\u002D' ) 以指示负值或 ASCII 加号'+' ('\u002B') 表示正值。返回结果整数值。

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

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

示例：

 parseInt("0", 10) returns 0
 parseInt("473", 10) returns 473
 parseInt("+42", 10) returns 42
 parseInt("-0", 10) returns 0
 parseInt("-FF", 16) returns -255
 parseInt("1100110", 2) returns 102
 parseInt("2147483647", 10) returns 2147483647
 parseInt("-2147483648", 10) returns -2147483648
 parseInt("2147483648", 10) throws a NumberFormatException
 parseInt("99", 8) throws a NumberFormatException
 parseInt("Kona", 10) throws a NumberFormatException
 parseInt("Kona", 27) returns 411787
 

参数：

s - 包含要解析的整数表示的 String

radix - 解析 s 时要使用的基数。

返回：

由指定基数中的字符串参数表示的整数。

抛出：

NumberFormatException - 如果 String 不包含可解析的 int 。

parseInt

public static int parseInt(CharSequence  s, int beginIndex, int endIndex, int radix) throws NumberFormatException 
            

将 CharSequence 参数解析为指定 radix 中的带符号 int，从指定的 beginIndex 开始并扩展到 endIndex - 1。

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

参数：

s - 包含要解析的 int 表示的 CharSequence

beginIndex - 开始索引，包括在内。

endIndex - 结束索引，独占。

radix - 解析 s 时要使用的基数。

返回：

由指定基数中的子序列表示的带符号的 int。

抛出：

NullPointerException - 如果 s 为空。

IndexOutOfBoundsException - 如果 beginIndex 为负，或者如果 beginIndex 大于 endIndex 或者如果 endIndex 大于 s.length()。

NumberFormatException - 如果 CharSequence 在指定的 radix 中不包含可解析的 int，或者如果 radix 小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX 。

自从：

9

parseInt

public static int parseInt(String  s) throws NumberFormatException 
            

将字符串参数解析为带符号的十进制整数。字符串中的字符必须全部是十进制数字，除了第一个字符可以是 ASCII 减号 '-' ('\u002D') 表示负值或 ASCII 加号 '+' ('\u002B') 表示正值。返回结果整数值，就像将参数和基数 10 作为参数提供给 parseInt(java.lang.String, int) 方法一样。

参数：

s - 包含要解析的 int 表示的 String

返回：

十进制参数表示的整数值。

抛出：

NumberFormatException - 如果字符串不包含可解析的整数。

parseUnsignedInt

public static int parseUnsignedInt(String  s, int radix) throws NumberFormatException 
            

将字符串参数解析为第二个参数指定的基数中的无符号整数。无符号整数将通常与负数关联的值映射到大于 MAX_VALUE 的正数。字符串中的字符必须都是指定基数的数字（由 Character.digit(char, int) 是否返回非负值确定），除了第一个字符可以是 ASCII 加号 '+' ('\u002B' )。返回结果整数值。

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

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

参数：

s - 包含要解析的无符号整数表示的 String

radix - 解析 s 时要使用的基数。

返回：

由指定基数中的字符串参数表示的整数。

抛出：

NumberFormatException - 如果 String 不包含可解析的 int 。

自从：

1.8

parseUnsignedInt

public static int parseUnsignedInt(CharSequence  s, int beginIndex, int endIndex, int radix) throws NumberFormatException 
            

将 CharSequence 参数解析为指定 radix 中的无符号 int，从指定的 beginIndex 开始并扩展到 endIndex - 1。

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

参数：

s - CharSequence 包含要解析的无符号 int 表示

beginIndex - 开始索引，包括在内。

endIndex - 结束索引，独占。

radix - 解析 s 时要使用的基数。

返回：

由指定基数中的子序列表示的无符号 int。

抛出：

NullPointerException - 如果 s 为空。

IndexOutOfBoundsException - 如果 beginIndex 为负，或者如果 beginIndex 大于 endIndex 或者如果 endIndex 大于 s.length()。

NumberFormatException - 如果 CharSequence 在指定的 radix 中不包含可解析的无符号 int，或者如果 radix 小于 Character.MIN_RADIX 或大于 Character.MAX_RADIX 。

自从：

9

parseUnsignedInt

public static int parseUnsignedInt(String  s) throws NumberFormatException 
            

将字符串参数解析为无符号十进制整数。字符串中的字符必须全部是十进制数字，除了第一个字符可以是 ASCII 加号 '+' ('\u002B' )。返回结果整数值，就像将参数和基数 10 作为参数提供给 parseUnsignedInt(java.lang.String, int) 方法一样。

参数：

s - 一个 String 包含要解析的无符号 int 表示

返回：

由十进制参数表示的无符号整数值。

抛出：

NumberFormatException - 如果字符串不包含可解析的无符号整数。

自从：

1.8

valueOf

public static Integer  valueOf(String  s, int radix) throws NumberFormatException 
            

返回一个 Integer 对象，其中包含在使用第二个参数给出的基数进行解析时从指定的 String 中提取的值。第一个参数被解释为表示第二个参数指定的基数中的有符号整数，就像将参数提供给 parseInt(java.lang.String, int) 方法一样。结果是一个 Integer 对象，表示字符串指定的整数值。

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

Integer.valueOf(Integer.parseInt(s, radix))

参数：

s - 要解析的字符串。

radix - 用于解释 s 的基数

返回：

一个 Integer 对象，其中包含由指定基数中的字符串参数表示的值。

抛出：

NumberFormatException - 如果 String 不包含可解析的 int 。

valueOf

public static Integer  valueOf(String  s) throws NumberFormatException 
            

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

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

Integer.valueOf(Integer.parseInt(s))

参数：

s - 要解析的字符串。

返回：

一个 Integer 对象保存由字符串参数表示的值。

抛出：

NumberFormatException - 如果字符串无法解析为整数。

valueOf

public static Integer  valueOf(int i)
            

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

参数：

i - 一个 int 值。

返回：

代表 i 的 Integer 实例。

自从：

1.5

byteValue

public byte byteValue()
            

在缩小基元转换后将此 Integer 的值作为 byte 返回。

重写：

byteValue 在类 Number 中

返回：

转换为类型 byte 后此对象表示的数值。

看Java 语言规范:

5.1.3 缩小原始转换

shortValue

public short shortValue()
            

在缩小基元转换后将此 Integer 的值作为 short 返回。

重写：

shortValue 在类 Number 中

返回：

转换为类型 short 后此对象表示的数值。

看Java 语言规范:

5.1.3 缩小原始转换

intValue

public int intValue()
            

将此 Integer 的值作为 int 返回。

指定者：

intValue 在类 Number 中

返回：

转换为类型 int 后此对象表示的数值。

longValue

public long longValue()
            

在扩大原始转换后将此 Integer 的值作为 long 返回。

指定者：

longValue 在类 Number 中

返回：

转换为类型 long 后此对象表示的数值。

看Java 语言规范:

5.1.2 拓宽原始转换

参见：

• toUnsignedLong(int)

floatValue

public float floatValue()
            

在扩展原始转换后将此 Integer 的值作为 float 返回。

指定者：

floatValue 在类 Number 中

返回：

转换为类型 float 后此对象表示的数值。

看Java 语言规范:

5.1.2 拓宽原始转换

doubleValue

public double doubleValue()
            

在扩展原始转换后将此 Integer 的值作为 double 返回。

指定者：

doubleValue 在类 Number 中

返回：

转换为类型 double 后此对象表示的数值。

看Java 语言规范:

5.1.2 拓宽原始转换

toString

public String  toString()
            

返回表示此 Integer 值的 String 对象。该值被转换为带符号的十进制表示形式并作为字符串返回，就像将整数值作为参数提供给 toString(int) 方法一样。

重写：

toString 在类 Object 中

返回：

此对象的值以 10 为基数的字符串表示形式。

hashCode

public int hashCode()
            

返回此 Integer 的哈希码。

重写：

hashCode 在类 Object 中

返回：

此对象的哈希码值，等于此 Integer 对象表示的原始 int 值。

参见：

• Object.equals(java.lang.Object)
• System.identityHashCode(java.lang.Object)

hashCode

public static int hashCode(int value)
            

返回 int 值的哈希码；与 Integer.hashCode() 兼容。

参数：

value - 要散列的值

返回：

int 值的哈希码值。

自从：

1.8

equals

public boolean equals(Object  obj)
            

将此对象与指定对象进行比较。当且仅当参数不是 null 并且是包含与该对象相同的 int 值的 Integer 对象时，结果为 true。

重写：

equals 在类 Object 中

参数：

obj - 要与之比较的对象。

返回：

true 如果对象相同； false否则。

参见：

• Object.hashCode()
• HashMap

getInteger

public static Integer  getInteger(String  nm)
            

确定具有指定名称的系统属性的整数值。

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

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

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

getInteger(nm, null)

参数：

nm - 属性名称。

返回：

属性的 Integer 值。

抛出：

SecurityException - 原因与 System.getProperty 相同

参见：

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

getInteger

public static Integer  getInteger(String  nm, int val)
            

确定具有指定名称的系统属性的整数值。

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

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

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

getInteger(nm, Integer.valueOf(val))

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

 Integer result = getInteger(nm, null);
 return (result == null) ? Integer.valueOf(val) : result;
 

避免在不需要默认值时不必要地分配 Integer 对象。

参数：

nm - 属性名称。

val - 默认值。

返回：

属性的 Integer 值。

抛出：

SecurityException - 原因与 System.getProperty 相同

参见：

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

getInteger

public static Integer  getInteger(String  nm, Integer  val)
            

返回具有指定名称的系统属性的整数值。第一个参数被视为系统属性的名称。系统属性可通过 System.getProperty(java.lang.String) 方法访问。然后根据 decode 方法将此属性的字符串值解释为整数值，并返回表示此值的 Integer 对象；总之：

• 如果属性值以两个 ASCII 字符 0x 或 ASCII 字符 # 开头，后面没有减号，则其余部分将被解析为十六进制整数，与方法 valueOf(java.lang.String, int) 完全相同，基数为 16。
• 如果属性值以 ASCII 字符 0 开头，后跟另一个字符，则它被解析为八进制整数，与方法 valueOf(java.lang.String, int) 完全相同，基数为 8。
• 否则，属性值将被解析为十进制整数，与方法 valueOf(java.lang.String, int) 完全相同，基数为 10。

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

参数：

nm - 属性名称。

val - 默认值。

返回：

属性的 Integer 值。

抛出：

SecurityException - 原因与 System.getProperty 相同

参见：

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

decode

public static Integer  decode(String  nm) throws NumberFormatException 
            

将 String 解码为 Integer 。接受由以下语法给出的十进制、十六进制和八进制数：

可解码字符串：

符号_选择 DecimalNumeral

符号_选择 0x HexDigits

符号_选择 0X HexDigits

符号_选择 # HexDigits

符号_选择 0 OctalDigits

符号：

-

+

DecimalNumeral, HexDigits， 和OctalDigits如第 3.10.1 节中所定义Java 语言规范, 除了数字之间不接受下划线。

可选符号和/或基数说明符（“0x”、“0X”、“#”或前导零）后面的字符序列由具有指示基数（10、16 或 8）的 Integer.parseInt 方法解析。此字符序列必须表示正值，否则将抛出 NumberFormatException 。如果指定的 String 的第一个字符是减号，则结果取反。 String 中不允许有空白字符。

参数：

nm - 要解码的 String。

返回：

一个 Integer 对象持有由 nm 表示的 int 值

抛出：

NumberFormatException - 如果 String 不包含可解析的整数。

参见：

• parseInt(java.lang.String, int)

compareTo

public int compareTo(Integer  anotherInteger)
            

在数值上比较两个 Integer 对象。

指定者：

compareTo 在接口 Comparable<Integer> 中

参数：

anotherInteger - 要比较的 Integer。

返回：

值 0 如果这个 Integer 等于参数 Integer ；如果此 Integer 在数值上小于参数 Integer，则该值小于 0；和大于 0 的值，如果此 Integer 在数值上大于参数 Integer（有符号比较）。

自从：

1.2

compare

public static int compare(int x, int y)
            

以数字方式比较两个 int 值。返回的值与将返回的值相同：

  Integer.valueOf(x).compareTo(Integer.valueOf(y))
 

参数：

x - 第一个要比较的 int

y - 要比较的第二个 int

返回：

值 0 如果 x == y ；如果 x < y 小于 0 的值；如果 x > y，则值大于 0

自从：

1.7

compareUnsigned

public static int compareUnsigned(int x, int y)
            

比较两个 int 值，在数值上将值视为无符号。

参数：

x - 第一个要比较的 int

y - 要比较的第二个 int

返回：

值 0 如果 x == y ；如果 x < y 为无符号值，则小于 0 的值；如果 x > y 为无符号值，则值大于 0

自从：

1.8

toUnsignedLong

public static long toUnsignedLong(int x)
            

通过无符号转换将参数转换为 long。在到 long 的无符号转换中，long 的高 32 位为零，低 32 位等于整数参数的位。因此，零和正 int 值映射到数值上相等的 long 值，负 int 值映射到等于输入加 2 的 long 值³².

参数：

x - 要转换为无符号 long 的值

返回：

通过无符号转换将参数转换为 long

自从：

1.8

divideUnsigned

public static int divideUnsigned(int dividend, int divisor)
            

返回第一个参数除以第二个参数的无符号商，其中每个参数和结果都被解释为无符号值。

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

参数：

dividend - 要划分的值

divisor - 进行除法的值

返回：

第一个参数除以第二个参数的无符号商

自从：

1.8

参见：

• remainderUnsigned(int, int)

remainderUnsigned

public static int remainderUnsigned(int dividend, int divisor)
            

返回第一个参数除以第二个参数的无符号余数，其中每个参数和结果都被解释为无符号值。

参数：

dividend - 要划分的值

divisor - 进行除法的值

返回：

第一个参数除以第二个参数的无符号余数

自从：

1.8

参见：

• divideUnsigned(int, int)

highestOneBit

public static int highestOneBit(int i)
            

在指定的 int 值中最高位（“最左边”）一位的位置返回一个最多只有一位的 int 值。如果指定值在其补码二进制表示中没有一位，即等于零，则返回零。

参数：

i - 要计算其最高一位的值

返回：

具有单个一位的 int 值，位于指定值中最高位的位置，如果指定值本身等于零，则为零。

自从：

1.5

lowestOneBit

public static int lowestOneBit(int i)
            

在指定的 int 值中最低位（“最右边”）一位的位置返回一个最多只有一位的 int 值。如果指定值在其补码二进制表示中没有一位，即等于零，则返回零。

参数：

i - 要计算其最低一位的值

返回：

具有单个一位的 int 值，位于指定值的最低位一位的位置，如果指定值本身等于零，则为零。

自从：

1.5

numberOfLeadingZeros

public static int numberOfLeadingZeros(int i)
            

返回指定 int 值的二进制补码表示形式中最高阶（“最左边”）一位之前的零位数。如果指定值在其二进制补码表示中没有一位，即等于零，则返回 32。

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

• 地板（日志₂(x)) = 31 - numberOfLeadingZeros(x)
• 天花板（日志₂(x)) = 32 - numberOfLeadingZeros(x - 1)

参数：

i - 要计算其前导零数的值

返回：

指定 int 值的二进制补码表示形式中最高阶（“最左边”）一位之前的零位数，如果该值等于零，则为 32。

自从：

1.5

numberOfTrailingZeros

public static int numberOfTrailingZeros(int i)
            

返回指定 int 值的二进制补码表示形式中最低位（“最右边”）一位之后的零位数。如果指定值在其二进制补码表示中没有一位，即等于零，则返回 32。

参数：

i - 要计算其尾随零数的值

返回：

指定 int 值的二进制补码表示中最低位（“最右边”）一位之后的零位数，如果该值等于零，则为 32。

自从：

1.5

bitCount

public static int bitCount(int i)
            

返回指定 int 值的二进制补码表示形式中的一位数。这个函数有时被称为人口数.

参数：

i - 要计算其位的值

返回：

指定 int 值的二进制补码表示中的一位数。

自从：

1.5

rotateLeft

public static int rotateLeft(int i, int distance)
            

返回通过将指定的 int 值的二进制补码表示向左旋转指定位数而获得的值。 （从左手或高位移出的位从右手或低位重新进入。）

请注意，负距离向左旋转等同于向右旋转：rotateLeft(val, -distance) == rotateRight(val, distance)。另请注意，旋转 32 的任何倍数都是空操作，因此除了旋转距离的最后五位之外的所有位都可以忽略，即使距离为负：rotateLeft(val, distance) == rotateLeft(val, distance & 0x1F)。

参数：

i - 其位要左移的值

distance - 向左循环的位数

返回：

通过将指定的 int 值的二进制补码表示向左旋转指定位数而获得的值。

自从：

1.5

rotateRight

public static int rotateRight(int i, int distance)
            

返回通过将指定的 int 值的二进制补码表示向右旋转指定位数而获得的值。 （位从右手或低位移出，从左侧或高位重新进入。）

请注意，负距离向右旋转等同于向左旋转：rotateRight(val, -distance) == rotateLeft(val, distance)。另请注意，旋转 32 的任何倍数都是空操作，因此除了旋转距离的最后五位之外的所有位都可以忽略，即使距离为负：rotateRight(val, distance) == rotateRight(val, distance & 0x1F)。

参数：

i - 其位要向右循环的值

distance - 向右循环的位数

返回：

通过将指定的 int 值的二进制补码表示向右旋转指定的位数获得的值。

自从：

1.5

reverse

public static int reverse(int i)
            

返回通过反转指定 int 值的二进制补码表示中的位顺序获得的值。

参数：

i - 要反转的值

返回：

通过反转指定 int 值中的位顺序获得的值。

自从：

1.5

compress

public static int compress(int i, int mask)
            

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

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

API 注意：

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

// Compressing drink to food
compress(0xCAFEBABE, 0xFF00FFF0) == 0xCABAB
 

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

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

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

// Logical shift right
compress(x, -1 << 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 : (1 << 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 节）可以按如下方式实现：

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

int sag(int i, int mask) {
  return compressLeft(i, mask) | Integer.compress(i, ~mask);
}

// Separate the sheep from the goats
sag(0xCAFEBABE, 0xFF00FFF0) == 0xCABABFEE
 

参数：

i - 要压缩其位的值

mask - 位掩码

返回：

压缩值

自从：

19

参见：

• expand(int, int)

expand

public static int expand(int i, int mask)
            

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

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

API 注意：

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

expand(0x0000CABAB, 0xFF00FFF0) == 0xCA00BAB0
 

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

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

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

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

// Expanding all bits returns the mask
expand(-1, 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的一位在int值中的位置的选择操作可以实现如下：

int select(int i, int n) {
  // the one-bit in i (the mask) with index n
  int nthBit = Integer.expand(1 << n, i);
  // the bit position of the one-bit with index n
  return Integer.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(int, int)

signum

public static int signum(int i)
            

返回指定 int 值的符号函数。 （如果指定值为负，则返回值为 -1；如果指定值为零，则返回值为 0；如果指定值为正，则返回值为 1。）

参数：

i - 要计算其符号的值

返回：

指定 int 值的符号函数。

自从：

1.5

reverseBytes

public static int reverseBytes(int i)
            

返回通过反转指定 int 值的二进制补码表示中的字节顺序获得的值。

参数：

i - 要反转其字节的值

返回：

通过反转指定 int 值中的字节获得的值。

自从：

1.5

sum

public static int sum(int a, int b)
            

根据 + 运算符将两个整数相加。

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a 和 b 的总和

自从：

1.8

参见：

• BinaryOperator

max

public static int max(int a, int b)
            

返回两个 int 值中较大的一个，就像调用 Math.max 一样。

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a 和 b 中的较大者

自从：

1.8

参见：

• BinaryOperator

min

public static int min(int a, int b)
            

返回两个 int 值中较小的一个，就像调用 Math.min 一样。

参数：

a - 第一个操作数

b - 第二个操作数

返回：

a 和 b 中较小的一个

自从：

1.8

参见：

• BinaryOperator

describeConstable

public Optional <Integer > describeConstable()
            

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

指定者：

describeConstable 在接口 Constable 中

返回：

Optional 描述了 Integer 实例

自从：

12

resolveConstantDesc

public Integer  resolveConstantDesc(MethodHandles.Lookup  lookup)
            

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

指定者：

resolveConstantDesc 在接口 ConstantDesc 中

参数：

lookup - 忽略

返回：

Integer 实例

自从：

12