java基础类Integer源码分析
目录
简介
字段
MIN_VALUE，MAX_VALUE
TYPE
digits
DigitTens，DigitOnes
sizeTable
value
SIZE，BYTES
产生Integer的方法（构造类与各种valueOf）
Integer缓存
new Integer
valueOf
产生int的方法（各种parse）
parseInt
parseUnsignedInt
重写继承的Number的各种方法（各种xxxValue）
各种产生String的方法
toString，toUnsignedString
toHexString，toOctalString，toBinaryString
三个比较方法，compareTo,compare,compareUnsigned
覆盖Object的各种方法
toString
hashCode
equals
简介
Integer类是java原始类型int的包装类
/**
* Integer类包装了一个原始类型int的值在一个对象中。
* 一个Integer类的对象包含了一个单一的int类型的字段。
*
*
此外，这个类提供了几个将int转为String和将String转为int的方法，
* 还有一些在处理int类型时有用的常量和方法。
*
*
实现的注解：位处理的实现方法（例如highestOneBit，numberOfTrailingZeros，numberOfTrailingZeros）
* 是基于Henry S. Warren, Jr.'s Hacker's Delight的材料。
*
* @author Lee Boynton
* @author Arthur van Hoff
* @author Josh Bloch
* @author Joseph D. Darcy
* @since JDK1.0
*/
public final class Integer extends Number implements Comparable
字段
MIN_VALUE，MAX_VALUE
/**
* 一个持有int类型的最小值的常量，-231，-2147483648
*/
@Native public static final int MIN_VALUE = 0x80000000;
//1后面3+7*4=31个0，对应2的31次方（1后面3个0对应1000对应8对应2的3次方）
/**
* 一个持有int类型的最大值的常量，231-1，2147483647
*/
@Native public static final int MAX_VALUE = 0x7fffffff;
//3+7*4=31个1，对应2的31次方-1（3个1对应111对应7对应2的3次方-1）TYPE
/**
* 代表着原始类型int的Class实例，类似int.class 原始类
*
* @since JDK1.1
*/
@SuppressWarnings("unchecked")
public static final Class TYPE = (Class) Class.getPrimitiveClass("int"); digits
/**
* 所有可能作为一个String代表数字的char，0-9和a-z，因为可能出现2-35进制。
*/
final static char[] digits = {
'0' , '1' , '2' , '3' , '4' , '5' ,
'6' , '7' , '8' , '9' , 'a' , 'b' ,
'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
'o' , 'p' , 'q' , 'r' , 's' , 't' ,
'u' , 'v' , 'w' , 'x' , 'y' , 'z'
};DigitTens，DigitOnes
/**这两个char数组是给getChars方法调用的
*
*/
final static char [] DigitTens = {
'0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
'1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
'2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
'3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
'4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
'5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
'6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
'7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
'8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
'9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
} ;
final static char [] DigitOnes = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
} ;sizeTable
/**
* 根据数组里面的值，进行大小判断，从而得到10进制下，有几位
*/
final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
99999999, 999999999, Integer.MAX_VALUE };value
/**
* Integer的值
*
*
注意它是private，final的，
* 别人不能对它修改，只能换一个Integer对象
*
*
Integer最重要的值，代表了这个Integer对象。
*
* @serial
*/
private final int value;
SIZE，BYTES
/**
* 用二进制补码形式表示int值的位数
*
* @since 1.5
*/
@Native public static final int SIZE = 32;
/**
* 用二进制补码形式表示整数值的字节数。
* 一个字节为8个bit，一个int总共4个byte，32个bit
*
* @since 1.8
*/
public static final int BYTES = SIZE / Byte.SIZE;产生Integer的方法（构造类与各种valueOf）
Integer缓存
/**
* 缓存，支持由JLS要求的-128到127（包含）的值的自动装箱的对象语义标识。
*
*
缓存在第一次使用时初始化。缓存的大小由选项 {@code -XX:AutoBoxCacheMax=} 控制。
* 在虚拟机初始化时，值IntegerCache.high可以被类sun.misc.VM中的私有系统属性设置并保存。
*
* 注意；它是私有的static内部类，只能由Integer类访问
*/
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
//第一次加载这个类的时候执行下面代码
static {
// high 值能够通过属性配置，但是默认是127
int h = 127;
//从sun.misc.VM得到high
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
//如果设置了的话，127<=high<=Integer.MAX_VALUE - 129
//即如果不超过上下限，即为设置的值，否则为上下限
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// 数组最大的长度是Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
//根据high和low创建integer数组cache
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
//cache中下标0对应-128，length-1对应high
cache[k] = new Integer(j++);
// 保证包含[-128, 127] (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
//私有的构造器，不能创建实例
private IntegerCache() {}
}
new Integer
直接new的integer是不会在IntegerCache中的
/**
* 构造一个新分配的Integer对象，它的值代表特定的int值。
*
* @param value the value to be represented by the
* {@code Integer} object.
*/
public Integer(int value) {
//直接设置value即可
this.value = value;
}
/**
* Constructs a newly allocated {@code Integer} object that
* represents the {@code int} value indicated by the
* {@code String} parameter. The string is converted to an
* {@code int} value in exactly the manner used by the
* {@code parseInt} method for radix 10.
*
* 构造一个新分配的Integer对象，它的值代表特定有String参数表明的int值。
* 这个字符串被转换为int值，用基数10，调用parseInt方法
*
* @param s the {@code String} to be converted to an
* {@code Integer}.
* @exception NumberFormatException if the {@code String} does not
* contain a parsable integer.
* @see java.lang.Integer#parseInt(java.lang.String, int)
*/
public Integer(String s) throws NumberFormatException {
this.value = parseInt(s, 10);
}valueOf
注意将int包装为Integer就会调用
Integer aInteger=1; //public static Integer valueOf(int i)
这个方法可能会使用IntegerCache里的Integer实例
/**
* 返回一个代表特定int值的Integer实例。
* 如果不需要一个新的Integer实例，这个方法应该比构造器 Integer(int)优先使用，
* 因为通过缓存频繁地请求值，这个方法可能会显著地提高空间和时间的效率。
*
*
这个方法通常情况下，会缓存包含-128到127的值，也可能缓存超过这个返回的值。
* （如果设置了{@code -XX:AutoBoxCacheMax=}，那就可能会超过）
*
* 注意：这个方法会在 Integer a=1 时被使用，用来包装int类型。变成 Integer a=Integer.valueOf(1)
*
* @param i an {@code int} value.
* @return an {@code Integer} instance representing {@code i}.
* @since 1.5
*/
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
//如果i在[IntegerCache.low,IntegerCache.high]
//就返回IntegerCache.cache数组中缓存的Integer对象
return IntegerCache.cache[i + (-IntegerCache.low)];
//如果不在范围内，直接调用 Integer(int)构造器返回
return new Integer(i);
}
下面的两个和上面的其实一样
/**
* Returns an {@code Integer} object holding the value
* extracted from the specified {@code String} when parsed
* with the radix given by the second argument. The first argument
* is interpreted as representing a signed integer in the radix
* specified by the second argument, exactly as if the arguments
* were given to the {@link #parseInt(java.lang.String, int)}
* method. The result is an {@code Integer} object that
* represents the integer value specified by the string.
*
* In other words, this method returns an {@code Integer}
* object equal to the value of:
*
*
* {@code new Integer(Integer.parseInt(s, radix))}
*
*
* @param s the string to be parsed.
* @param radix the radix to be used in interpreting {@code s}
* @return an {@code Integer} object holding the value
* represented by the string argument in the specified
* radix.
* @exception NumberFormatException if the {@code String}
* does not contain a parsable {@code int}.
*/
public static Integer valueOf(String s, int radix) throws NumberFormatException {
return Integer.valueOf(parseInt(s,radix));
}
/**
* Returns an {@code Integer} object holding the
* value of the specified {@code String}. The argument is
* interpreted as representing a signed decimal integer, exactly
* as if the argument were given to the {@link
* #parseInt(java.lang.String)} method. The result is an
* {@code Integer} object that represents the integer value
* specified by the string.
*
* In other words, this method returns an {@code Integer}
* object equal to the value of:
*
*
* {@code new Integer(Integer.parseInt(s))}
*
*
* @param s the string to be parsed.
* @return an {@code Integer} object holding the value
* represented by the string argument.
* @exception NumberFormatException if the string cannot be parsed
* as an integer.
*/
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}产生int的方法（各种parse）
parseInt
/**
* 将string参数解析为一个带符号的整数，进制由第二个参数指定。
* 字符串中的character必须是对应进制的数字（由Character.digit(char ch, int radix)返回的非负值决定），
* 但是第一个字符可以是ASCII的负数记号{@code '-'} ({@code '\u005Cu002D'})来表明是负值
* 或者 一个ASCII的正数记号{@code '+'}({@code '\u005Cu002B'})来表明是正值。
* 返回结果的整数值。
*
*
如果有下面之一的情况发生，抛出NumberFormatException
*
*
* - 第一个参数是null或者长度为0
*
*
- 进制比Character.MIN_RADIX（2）小或者比Character.MAX_RADIX（36） 大
*
*
- string的某一个字符不是特定进制的数字，除了string长度大于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 超出int的最大范围
* parseInt("99", 8) throws a NumberFormatException 9不是8进制的数字
* parseInt("Kona", 10) throws a NumberFormatException 英文不是10进制的数字
* parseInt("Kona", 27) returns 411787 如果是27位，可以用英文
*
*
* 可以发现，当radix大于10的时候，可以用a,b,c,d,z 代表10，11，12，13，35
*
*
最高为36进制，0-9，a-z，其中一个z代表35
*
* @param s the {@code String} containing the integer
* representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @return the integer represented by the string argument in the
* specified radix.
* @exception NumberFormatException 如果string不包含一个可解析的int
*/
public static int parseInt(String s, int radix)
throws NumberFormatException
{
/*
* 警告：这个方法可能在虚拟机初始化时调用，早于IntegerCache的初始化，注意不要调用valueOf方法。
*/
//排除s为null和radix不在范围内的情况。
if (s == null) {
throw new NumberFormatException("null");
}
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
int result = 0;
boolean negative = false; //默认是正数
int i = 0, len = s.length();
//由于后面的result是对应的负值，正数的limit是-Integer.MAX_VALUE，负数的limit是Integer.MIN_VALUE
int limit = -Integer.MAX_VALUE;
int multmin;
int digit;
if (len > 0) {
char firstChar = s.charAt(0);
//注意ascii中的顺序：+ - 0 5 9 A Z a z
if (firstChar < '0') { // 这种情况，首字符不可能是数字和字母，只可能是正负号或者其他
if (firstChar == '-') { //首字符为负号
negative = true; //这种情况为负数
limit = Integer.MIN_VALUE;
} else if (firstChar != '+') //首字符为正号时，negative无需改变
//不是正负号时，抛出错误
throw NumberFormatException.forInputString(s);
if (len == 1) // 到这里，首字符为正负号，但是这种情况，后面得有别的,不能len=1
throw NumberFormatException.forInputString(s);
i++; //i为string中的坐标
}
//处理为正负号的首字符结束
//multmin是保证 result *= radix 后result将string参数解析为一个带符号的整数。
* 字符串中的character必须是数字字符，
* 但是第一个字符可以是ASCII的负数记号{@code '-'} ({@code '\u005Cu002D'})来表明是负值
* 或者 一个ASCII的正数记号{@code '+'}({@code '\u005Cu002B'})来表明是正值。
* 返回结果的整数值，就像使用parseInt(s,10)的结果一样。
*
* @param s a {@code String} containing the {@code int}
* representation to be parsed
* @return the integer value represented by the argument in decimal.
* @exception NumberFormatException if the string does not contain a
* parsable integer.
*/
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}
parseUnsignedInt
/**
* 将string参数解析为一个无符号整数，进制由第二个参数指定。
* 无符号整数通常将负数关联为大于max_value的整数。
*
*
字符串中的字符必须都是特定进制的数字（由Character.digit(char, int)返回的非负值决定），
* 除了首字符可以说ASCII的正号 {@code '+'} ({@code '\u005Cu002B'}。结果整数会被返回。
*
*
如果以下情况之一出现，报错NumberFormatException
*
*
* - 第一个参数是null或者长度为0
*
*
- 进制比Character.MIN_RADIX（2）小或者比Character.MAX_RADIX（36） 大
*
*
- 字符串的任何字符不是特定进制的数字，除非首字母是正号而且字符串长度大于1
*
*
- 代表字符串的值大于最大的无符号整数int，232-1.
*
*
*
* 这样就是说给的字符串代表的值为[0,232-1]
*
*
如果字符串代表[0,231-1]，普通的int正数范围内，与普通情况一样。
* 如果在[231,232-1]，会返回负数，负数的二进制表示结果和字符串转为二进制一样。
*
*
* @param s the {@code String} containing the unsigned integer
* representation to be parsed
* @param radix the radix to be used while parsing {@code s}.
* @return the integer represented by the string argument in the
* specified radix.
* @throws NumberFormatException if the {@code String}
* does not contain a parsable {@code int}.
* @since 1.8
*/
public static int parseUnsignedInt(String s, int radix)
throws NumberFormatException {
if (s == null) {
//排除s为null，报错
throw new NumberFormatException("null");
}
int len = s.length();
if (len > 0) {
char firstChar = s.charAt(0);
if (firstChar == '-') {
//排除首字符为负号，报错
throw new
NumberFormatException(String.format("Illegal leading minus sign " +
"on unsigned string %s.", s));
} else {
if (len <= 5 || // Integer.MAX_VALUE 在进制为 Character.MAX_RADIX 有6位
(radix == 10 && len <= 9) ) { // Integer.MAX_VALUE 在10进制 由10位，2147483647
//如果len<=5，保证对于所有进制都是正数。
//如果10进制，len <= 9，必定是正数
//正数情况下，可以视为普通的int情况，直接调用parseInt方法
return parseInt(s, radix);
} else {
//这种情况下，s可能超过 Integer.MAX_VALUE，用long的方法解析
long ell = Long.parseLong(s, radix);
if ((ell & 0xffff_ffff_0000_0000L) == 0) {
//这个证明结果只有后32位存在1，前32位必定为0，在int的32位的范围内，可以强转为int
return (int) ell;
} else {
throw new
NumberFormatException(String.format("String value %s exceeds " +
"range of unsigned int.", s));
}
}
}
} else {
//排除s长度为0，报错
throw NumberFormatException.forInputString(s);
}
}
/**
* Parses the string argument as an unsigned decimal integer. The
* characters in the string must all be decimal digits, except
* that the first character may be an an ASCII plus sign {@code
* '+'} ({@code '\u005Cu002B'}). The resulting integer value
* is returned, exactly as if the argument and the radix 10 were
* given as arguments to the {@link
* #parseUnsignedInt(java.lang.String, int)} method.
*
*
将string参数解析为一个无符号的整数。
* 字符串中的character必须是数字字符，
* 但是第一个字符可以是一个ASCII的正数记号{@code '+'}({@code '\u005Cu002B'})来表明是正值。
* 返回结果的整数值，就像使用parseUnsignedInt(s,10)的结果一样。
*
* @param s a {@code String} containing the unsigned {@code int}
* representation to be parsed
* @return the unsigned integer value represented by the argument in decimal.
* @throws NumberFormatException if the string does not contain a
* parsable unsigned integer.
* @since 1.8
*/
public static int parseUnsignedInt(String s) throws NumberFormatException {
return parseUnsignedInt(s, 10);
}
重写继承的Number的各种方法（各种xxxValue）
注意：Integer自动拆箱为int就是调用intValue的方法
int b=aInteger; //public int intValue()
可以看到就是对基础字段value进行各种强制转换
/**
* Returns the value of this {@code Integer} as a {@code byte}
* after a narrowing primitive conversion.
* @jls 5.1.3 Narrowing Primitive Conversions
*/
public byte byteValue() {
return (byte)value;
}
/**
* Returns the value of this {@code Integer} as a {@code short}
* after a narrowing primitive conversion.
* @jls 5.1.3 Narrowing Primitive Conversions
*/
public short shortValue() {
return (short)value;
}
/**
* Returns the value of this {@code Integer} as an
* {@code int}.
*/
public int intValue() {
return value;
}
/**
* Returns the value of this {@code Integer} as a {@code long}
* after a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
* @see Integer#toUnsignedLong(int)
*/
public long longValue() {
return (long)value;
}
/**
* Returns the value of this {@code Integer} as a {@code float}
* after a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
*/
public float floatValue() {
return (float)value;
}
/**
* Returns the value of this {@code Integer} as a {@code double}
* after a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
*/
public double doubleValue() {
return (double)value;
}各种产生String的方法
toString，toUnsignedString
/**
* 返回一个代表第一个参数的字符串，进制由第二个参数指定。
*
*
如果进制小于Character.MIN_RADIX或者大于Character.MAX_RADIX，
* 就使用10进制。
*
*
如果第一个参数是负的，结果的第一个元素是ASCII的负号{@code '-'}({@code '\u005Cu002D'})。
* 如果第一个参数是非负的，结果不会显示负号字符。
*
*
结果剩余的字符代表了第一个参数的大小。
* 如果大小是0，它由一个单独的0字符{@code '0'}({@code '\u005Cu0030'})代表。
* 否则，大小的代表的首字符不会是字符0.
* 会使用下面的ASCII字符作为数字：
*
*
* {@code 0123456789abcdefghijklmnopqrstuvwxyz}
*
*
* 它们是从{@code '\u005Cu0030'}到{@code '\u005Cu0039'}和
* {@code '\u005Cu0061'}到{@code '\u005Cu007A'}.
* 如果进制是N，那么这些字符的前N个被按显示的顺序，对应与数字N。
* 因此，对于16进制的数字是{@code 0123456789abcdef}.（这16个字符，第几个就对应数字几，从0开始，第15个f对应15）
* 如果要求大写的字母，可以对结果调用String.toUpperCase()
*
*
* {@code Integer.toString(n, 16).toUpperCase()}
*
*
* @param i an integer to be converted to a string.
* @param radix the radix to use in the string representation.
* @return a string representation of the argument in the specified radix.
* @see java.lang.Character#MAX_RADIX
* @see java.lang.Character#MIN_RADIX
*/
public static String toString(int i, int radix) {
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
//如果进制超过范围，则变为10进制
radix = 10;
/* 如果是10进制，使用更快的版本，integer本身的toString方法*/
if (radix == 10) {
return toString(i);
}
char buf[] = new char[33]; //存放结果的char数组
boolean negative = (i < 0);
int charPos = 32; //写入char数组的指针，从最后一格写入
if (!negative) {
//把i变成负数
i = -i;
}
while (i <= -radix) {
//当i<=radix，例如i<=16,此时i还能被radix除
buf[charPos--] = digits[-(i % radix)]; //charPos的位置的结果是digits数组的下标为-(i mod radix)
i = i / radix;
}
buf[charPos] = digits[-i]; //此时-radix返回一个代表无符号整数的第一个参数的字符串，进制由第二个参数指定。
*
* 如果进制小于Character.MIN_RADIX或者大于Character.MAX_RADIX，
* 就使用10进制。
*
*
注意：因为第一个参数被视为无符号整数，不会打印任何符号（正负号）
*
*
如果大小是0，它由一个单独的0字符{@code '0'}({@code '\u005Cu0030'})代表。
* 否则，大小的代表的首字符不会是字符0.
*
*
radix的行为和用作数字的字符与toString(int, int)一样。
*
* @param i an integer to be converted to an unsigned string.
* @param radix the radix to use in the string representation.
* @return an unsigned string representation of the argument in the specified radix.
* @see #toString(int, int)
* @since 1.8
*/
public static String toUnsignedString(int i, int radix) {
//先将i变成无符号的long，再转为string
return Long.toUnsignedString(toUnsignedLong(i), radix);
}
toHexString，toOctalString，toBinaryString
/**
* 返回一个代表整数参数的字符串，字符串代表的整数是16进制的无符号integer
*
*
如果参数是负数，返回的无符号整数是参数+232。
* 否则，它与参数相同。值被转换为开头没有额外的0的，16进制的ASCII数字构成的字符串。
*
*
参数的值能被恢复，通过调用 Integer.parseUnsignedInt(s, 16)
*
*
如果无符号整数大小为0，它由一个单独的0字符表示。{@code '0'} ({@code '\u005Cu0030'})
* 否则，返回的无符号整数的第一个字符不会是0字符。
* 下面的字符用作16进制的数字：
*
*
* {@code 0123456789abcdef}
*
*
* 它们是从{@code '\u005Cu0030'}到{@code '\u005Cu0039'}和
* {@code '\u005Cu0061'}到{@code '\u005Cu007A'}.
* 如果要求大写的字母，可以调用Integer.toHexString(n).toUpperCase()
*
*
* @param i an integer to be converted to a string.
* @return the string representation of the unsigned integer value
* represented by the argument in hexadecimal (base 16).
* @see #parseUnsignedInt(String, int)
* @see #toUnsignedString(int, int)
* @since JDK1.0.2
*/
public static String toHexString(int i) {
return toUnsignedString0(i, 4);
}
/**
* Returns a string representation of the integer argument as an
* unsigned integer in base 8.
*
*
The unsigned integer value is the argument plus 232
* if the argument is negative; otherwise, it is equal to the
* argument. This value is converted to a string of ASCII digits
* in octal (base 8) with no extra leading {@code 0}s.
*
*
The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Integer#parseUnsignedInt(String, int)
* Integer.parseUnsignedInt(s, 8)}.
*
*
If the unsigned magnitude is zero, it is represented by a
* single zero character {@code '0'} ({@code '\u005Cu0030'});
* otherwise, the first character of the representation of the
* unsigned magnitude will not be the zero character. The
* following characters are used as octal digits:
*
*
* {@code 01234567}
*
*
* These are the characters {@code '\u005Cu0030'} through
* {@code '\u005Cu0037'}.
*
* @param i an integer to be converted to a string.
* @return the string representation of the unsigned integer value
* represented by the argument in octal (base 8).
* @see #parseUnsignedInt(String, int)
* @see #toUnsignedString(int, int)
* @since JDK1.0.2
*/
public static String toOctalString(int i) {
return toUnsignedString0(i, 3);
}
/**
* Returns a string representation of the integer argument as an
* unsigned integer in base 2.
*
* The unsigned integer value is the argument plus 232
* if the argument is negative; otherwise it is equal to the
* argument. This value is converted to a string of ASCII digits
* in binary (base 2) with no extra leading {@code 0}s.
*
*
The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Integer#parseUnsignedInt(String, int)
* Integer.parseUnsignedInt(s, 2)}.
*
*
If the unsigned magnitude is zero, it is represented by a
* single zero character {@code '0'} ({@code '\u005Cu0030'});
* otherwise, the first character of the representation of the
* unsigned magnitude will not be the zero character. The
* characters {@code '0'} ({@code '\u005Cu0030'}) and {@code
* '1'} ({@code '\u005Cu0031'}) are used as binary digits.
*
* @param i an integer to be converted to a string.
* @return the string representation of the unsigned integer value
* represented by the argument in binary (base 2).
* @see #parseUnsignedInt(String, int)
* @see #toUnsignedString(int, int)
* @since JDK1.0.2
*/
public static String toBinaryString(int i) {
return toUnsignedString0(i, 1);
}
/**将integer转为一个无符号数字。
* @param val 转换为数字的原始值int
* @param shift log2(转换的进制),2进制为1，8进制为3，16进制为4
* @return
*/
private static String toUnsignedString0(int val, int shift) {
// assert shift > 0 && shift <=5 : "Illegal shift value";
// mag=32-val作为二进制时前面所有的0的个数=val二进制时需要的位数
int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
//chars为标识转换成char数组需要的长度，最小是1（因为有可能val=0）
int chars = Math.max(((mag + (shift - 1)) / shift), 1);
char[] buf = new char[chars]; //创建chars大小的char数组buf
//在buf数组中，从下标0开始，长度为chars，填入数值为val，进制为2的shift次方的无符号整数
formatUnsignedInt(val, shift, buf, 0, chars);
// 使用接管buf的特殊字符串构造器
return new String(buf, true);
}
/**
* 将一个long（视为无符号整数）放入字符缓存区
* @param val the unsigned int to format
* @param shift the log2 of the base to format in (4 for hex, 3 for octal, 1 for binary)
* @param buf the character buffer to write to
* @param offset the offset in the destination buffer to start at
* @param len the number of characters to write
* @return the lowest character location used
*/
static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
int charPos = len; //从最后一格开始写入
int radix = 1 << shift; //进制为2的shift次方
int mask = radix - 1; //a mod radix=a & radix-1 当radix是2的n次方时
do {
//先--charPos,因为一开始为len
buf[offset + --charPos] = Integer.digits[val & mask]; //对应的位为mod的结果
val >>>= shift; //相当于val=val/radix
} while (val != 0 && charPos > 0); //当val不为0 而且指针>0
return charPos;
}
三个比较方法，compareTo,compare,compareUnsigned
/**
* 数值上比较两个Integer，实际调用compare方法
*
* @param anotherInteger the {@code Integer} to be compared.
* @return 如果这个Integer与anotherInteger相同，返回0；
* Integer小于anotherInteger，返回-1；
* Integer大于anotherInteger，返回1；
* @since 1.2
*/
public int compareTo(Integer anotherInteger) {
return compare(this.value, anotherInteger.value);
}
/**
* 数值上，比较两个int值。返回的值会与下面的语句返回的相同
*
* Integer.valueOf(x).compareTo(Integer.valueOf(y))
*
*
* @param x the first {@code int} to compare
* @param y the second {@code int} to compare
* @return 如果x==y，返回0。
* 如果xy,返回一个大于0的值，1。
* @since 1.7
*/
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
/**
* 比较两个视为无符号整数的int值。
*
* @param x the first {@code int} to compare
* @param y the second {@code int} to compare
* @return the value {@code 0} if {@code x == y}; a value less
* than {@code 0} if {@code x < y} as unsigned values; and
* a value greater than {@code 0} if {@code x > y} as
* unsigned values
* @since 1.8
*/
public static int compareUnsigned(int x, int y) {
return compare(x + MIN_VALUE, y + MIN_VALUE);
//两者加上MIN_VALUE，相当于减去2147483648，再比较
//这样无符号对应[0,2^32-1] 变成[-2^31.2^31-1]
} 覆盖Object的各种方法
toString
/**
* 返回一个代表这个Integer的String对象。
* 这个Integer的值被转换成有符号的数字表示，并以字符串返回，就像调用toString(int)方法。
*
* @return a string representation of the value of this object in
* base 10.
*/
public String toString() {
//调用了最开始的toString方法，以这个Integer的value作为参数
return toString(value);
}hashCode
/**
* 返回这个Integer的hashcode（其实返回的是这个integer的int值）
*
* @return a hash code value for this object, equal to the
* primitive {@code int} value represented by this
* {@code Integer} object.
*
*/
@Override
public int hashCode() {
//调用下面的这个方法
return Integer.hashCode(value);
}
/**
* 返回对于一个int的hashcode，与Integer.hashCode()兼容。
* 返回的hashcode就是参数value
*
* @param value the value to hash
* @since 1.8
*
* @return a hash code value for a {@code int} value.
*/
public static int hashCode(int value) {
return value;
}equals
/**
* 将这个对象与特定对象比较。
* 当且仅当参数不为null，而且是一个Integer对象，而且有着与这个对象相同的int值，才返回true。
*
* @param obj the object to compare with.
* @return {@code true} if the objects are the same;
* {@code false} otherwise.
*/
public boolean equals(Object obj) {
if (obj instanceof Integer) {
//先判断参数是否为Integer类型
//参数强转成Integer，调用intValue得到int值，双方比较即可
return value == ((Integer)obj).intValue();
}
return false;
}