Java 源码--Integer

Integer类继承Number类,实现Comparable接口。Integer类被修饰为final,所以其不可被继承。

字段

MIN_VALUE

最小值,@Native表示该字段可以从本地代码引用。

1
@Native public static final int MIN_VALUE = 0x80000000;

MAX_VALUE

最大值。

1
@Native public static final int MAX_VALUE = 0x7fffffff;

TYPE

类原始类型int的类实例。@SuppressWarnings(“unchecked”)表示该字段应该抑制unchecked的编译器警告。

1
2
@SuppressWarnings("unchecked")
public static final Class<Integer> TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

digits

所有可以表示为字符的数字。此变量是默认修饰符 ,只能在包内访问。

1
2
3
4
5
6
7
8
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

处理大的数,代表十位。

1
2
3
4
5
6
7
8
9
10
11
12
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',
} ;

DigitOnes

处理大的数,代表个位。

1
2
3
4
5
6
7
8
9
10
11
12
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

为了得到十进制的位数。

1
2
final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
99999999, 999999999, Integer.MAX_VALUE };

value

Integer的值,value被定义为final,即常量,值不可更改。

1
private final int value;

SIZE

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

1
@Native public static final int SIZE = 32;

BYTES

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

1
public static final int BYTES = SIZE / Byte.SIZE;

serialVersionUID

Integer的序列化版本号。

1
@Native private static final long serialVersionUID = 1360826667806852920L;

构造方法

Integer(int value)

1
2
3
public Integer(int value) {
this.value = value;
}

Integer(String s)

1
2
3
public Integer(String s) throws NumberFormatException {
this.value = parseInt(s, 10);
}

方法

toString(int i, int radix)

i是要转换为字符串的整数,radix是在字符串表示中使用的基数,返回基数radix表示的i的字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public static String toString(int i, int radix) {
// 如果radix不在合法的基数范围之内,使用10作为基数,范围2~36。
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
radix = 10;

// 如果基数是10,使用更加快速的转换方法。
if (radix == 10) {
return toString(i);
}

// Integer转化为以2为基数的字符串最多需要32位,并且有可能需要一位来表示'-'字符。
char buf[] = new char[33];
boolean negative =(i < 0);
// buf[]下标。
int charPos = 32;

// 如果i是非负数,将i变为负数。
if (!negative) {
i = -i;
}

// 计算i转换为以radix为基数的值,从后向前遍历buf[],并放入bug中。
// 转化为负数来操作是因为正数取不到128。
while (i <= -radix) {
buf[charPos--] = digits[-(i % radix)];
i = i / radix;
}
buf[charPos] = digits[-i];

// 如果是负数,加上字符'-'。
if (negative) {
buf[--charPos] = '-';
}

// 返回buf[]中有值的部分的字符串。
return new String(buf, charPos, (33 - charPos));
}

toUnsignedString(int i, int radix)

i是要转换为字符串的整数,radix是在字符串表示中使用的基数,返回无符号整数i以基数radix表示的字符串。具体参考Long的源码阅读。

1
2
3
public static String toUnsignedString(int i, int radix) {
return Long.toUnsignedString(toUnsignedLong(i), radix);
}

toHexString(int i)

i是要转换为字符串的整数,返回无符号整数i以基数16表示的字符串。

1
2
3
public static String toHexString(int i) {
return toUnsignedString0(i, 4);
}

toOctalString(int i)

i是要转换为字符串的整数,返回无符号整数i以基数8表示的字符串。

1
2
3
public static String toOctalString(int i) {
return toUnsignedString0(i, 3);
}

toBinaryString(int i)

i是要转换为字符串的整数,返回无符号整数i以基数2表示的字符串。

1
2
3
public static String toBinaryString(int i) {
return toUnsignedString0(i, 1);
}

toUnsignedString0(int val, int shift)

将val转换为以shift表示的基数的字符串,val是要转换的整数,shift是log2xlog_{2}x的值,x是进制数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private static String toUnsignedString0(int val, int shift) {
// assert shift > 0 && shift <=5 : "Illegal shift value";
// 得到val的二进制的有意义的位数,例如126对应的msg是7,-126对应的mag是32。
int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
// msg位数转换为2^shift进制的位数
int chars = Math.max(((mag + (shift - 1)) / shift), 1);
char[] buf = new char[chars];

// 进行转换
formatUnsignedInt(val, shift, buf, 0, chars);

// Use special constructor which takes over "buf".
return new String(buf, true);
}

formatUnsignedInt(int val, int shift, char[] buf, int offset, int len)

val是要格式化的整数,shift是要格式化的基数的代表,4代表十六进制,3代表八进制,1代表二进制,buf是要写入的字符数组,offset是buf中开始的位置,len是要写入buf的长度,返回buf中最低位的位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
int charPos = len;
int radix = 1 << shift;
int mask = radix - 1;
// 此过程相当于从右向左遍历val的二进制,每shift位转换为十进制对应radix进制的一位数。
// 就如同二进制转换为十六进制时,每四位换算成十进制就是十六进制的一位;二进制转换为八进制时,每三位换算成十进制就是八进制的一位。
do {
buf[offset + --charPos] = Integer.digits[val & mask];
val >>>= shift;
} while (val != 0 && charPos > 0);

return charPos;
}

toString(int i)

将i转换为string类型,返回String类型的i。

1
2
3
4
5
6
7
8
9
10
public static String toString(int i) {
if (i == Integer.MIN_VALUE)
return "-2147483648";
// 负数有一个符号位
int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
char[] buf = new char[size];
// 将每一位转换为字符
getChars(i, size, buf);
return new String(buf, true);
}

toUnsignedString(int i)

1
2
3
public static String toUnsignedString(int i) {
return Long.toString(toUnsignedLong(i));
}

getChars(int i, int index, char[] buf)

将整数i一个字符一个字符地写入buf,index是buf的起始位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
static void getChars(int i, int index, char[] buf) {
int q, r;
// buf的下标
int charPos = index;
// 正负数标志
char sign = 0;

// 如果是负数,将sign赋值为'-'
if (i < 0) {
sign = '-';
i = -i;
}

// Generate two digits per iteration
// 以中间位数为界限,大的数使用一种算法,小的数使用一种算法
// 2^16=65536
while (i >= 65536) {
q = i / 100;
// really: r = i - (q * 100);
// (q << 6) + (q << 5) + (q << 2) = q * (2^6 + 2^5 + 2^2) = q * 100
r = i - ((q << 6) + (q << 5) + (q << 2));
i = q;
buf [--charPos] = DigitOnes[r];
buf [--charPos] = DigitTens[r];
}

// Fall thru to fast mode for smaller numbers
// assert(i <= 65536, i);
for (;;) {
// 为什么不使用i/10呢???因为效率方面乘法优于除法,位运算优于乘法
// 2^19=524288
// 2^15<52429<2^16
// 为什么是16+3呢???为了精度
q = (i * 52429) >>> (16+3);
r = i - ((q << 3) + (q << 1)); // r = i-(q*10) ...
buf [--charPos] = digits [r];
i = q;
if (i == 0) break;
}
// 符号
if (sign != 0) {
buf [--charPos] = sign;
}
}

stringSize(int x)

获取整型x转为string之后的字符串长度。

1
2
3
4
5
static int stringSize(int x) {
for (int i=0; ; i++)
if (x <= sizeTable[i])
return i+1;
}

parseInt(String s, int radix)

将字符串s以radix为基数转换为有符号整型数。如果发生以下任何一种情况,则抛出类型NumberFormatException的异常:

  • 第一个参数是null或是长度为零的字符串。
  • 基数小于Character.MIN_RADIX或大于Character.MAX_RADIX
  • 字符串的任何字符不是指定基数的数字,除了第一个字符可能是减号或加号,前提是字符串长度大于1.
  • 由字符串表示的值不是int类型的值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public static int parseInt(String s, int radix) throws NumberFormatException {

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();
int limit = -Integer.MAX_VALUE;
int multmin;
int digit;

if (len > 0) {
char firstChar = s.charAt(0);
// 首先检查第一个字符是否是符号
if (firstChar < '0') { // Possible leading "+" or "-"
if (firstChar == '-') {
negative = true;
limit = Integer.MIN_VALUE;
} else if (firstChar != '+')
throw NumberFormatException.forInputString(s);

if (len == 1) // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
i++;
}
multmin = limit / radix;
while (i < len) {
// 积极消极避免MAX_VALUE附近的意外
// 获取以radix为基数的字符的十进制表示,Character.digit('f', 16) = 15
digit = Character.digit(s.charAt(i++),radix);
if (digit < 0) {
throw NumberFormatException.forInputString(s);
}
// 避免result*radix数值超过整型范围
if (result < multmin) {
throw NumberFormatException.forInputString(s);
}
// 进位
result *= radix;
// 避免result-digit数值超过整型范围
if (result < limit + digit) {
throw NumberFormatException.forInputString(s);
}
result -= digit;
}
} else {
throw NumberFormatException.forInputString(s);
}
return negative ? result : -result;
}

parseInt(String s)

将字符串s以10为基数转换为有符号整型数。

1
2
3
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}

parseUnsignedInt(String s, int radix)

将字符串s以radix为基数转换为无符号整型数。如果发生以下任何一种情况,则抛出类型NumberFormatException的异常:

  • 第一个参数是null或是长度为零的字符串。
  • 基数小于Character.MIN_RADIX或大于Character.MAX_RADIX
  • 字符串的任何字符不是指定基数的数字,除了第一个字符可能是加号,前提是字符串长度大于1.
  • 由字符串表示的值大于最大的无符号整数值23112^{31}-1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public static int parseUnsignedInt(String s, int radix)
throws NumberFormatException {
if (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 {
// 此处有一个分界线,若以最大基数即36转换字符串,则该字符串长度不能超过5,否则会超过int的取值范围
// 至于为什么十进制特殊了一下,可能是十进制比较常用吧,不然使用Long处理会占用空间吧。
if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
(radix == 10 && len <= 9) ) { // Integer.MAX_VALUE in base 10 is 10 digits
return parseInt(s, radix);
} else {
long ell = Long.parseLong(s, radix);
// 判断ell是否超出int的取值范围
if ((ell & 0xffff_ffff_0000_0000L) == 0) {
return (int) ell;
} else {
throw new NumberFormatException(String.format("String value %s exceeds " + "range of unsigned int.", s));
}
}
}
} else {
throw NumberFormatException.forInputString(s);
}
}

parseUnsignedInt(String s)

将字符串s以10为基数转换为无符号整型数。

1
2
3
public static int parseInt(String s) throws NumberFormatException {
return parseInt(s,10);
}

Integer valueOf(String s, int radix)

以radix为基数将字符串s转换为Integer类型。返回的Integer类型的数优先从缓存中获取。

1
2
3
public static Integer valueOf(String s, int radix) throws NumberFormatException {
return Integer.valueOf(parseInt(s,radix));
}

valueOf(String s)

以10为基数将字符串s转换为Integer类型。返回的Integer类型的数优先从缓存中获取。

1
2
3
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}

valueOf(int i)

将整型数i转换为Integer类型数。返回的Integer类型的数优先从缓存中获取。

1
2
3
4
5
6
public static Integer valueOf(int i) {
// 先从缓存中获取
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}

byteValue()

返回byte类型的值。

1
2
3
public byte byteValue() {
return (byte)value;
}

shortValue()

返回short类型的值。

1
2
3
public short shortValue() {
return (short)value;
}

intValue()

返回int类型的值。

1
2
3
public int intValue() {
return value;
}

longValue()

返回long类型的值。

1
2
3
public long longValue() {
return (long)value;
}

floatValue()

返回long类型的值。

1
2
3
public float floatValue() {
return (float)value;
}

doubleValue()

返回double类型的值。

1
2
3
public double doubleValue() {
return (double)value;
}

toString()

返回String类型。

1
2
3
public String toString() {
return toString(value);
}

hashCode()

返回哈希值。由此可见,Integer对象的hashcode值是它的值。

1
2
3
4
@Override
public int hashCode() {
return Integer.hashCode(value);
}

hashCode(int value)

返回value的哈希值。

1
2
3
public static int hashCode(int value) {
return value;
}

equals(Object obj)

判断obj的value与调用该方法的对象的value是否相等。

1
2
3
4
5
6
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}

getInteger(String nm)

返回系统属性nm的整数值。

1
2
3
public static Integer getInteger(String nm) {
return getInteger(nm, null);
}

getInteger(String nm, int val)

返回系统属性nm的整数值,如果为空,返回默认的val的Integer。

1
2
3
4
public static Integer getInteger(String nm, int val) {
Integer result = getInteger(nm, null);
return (result == null) ? Integer.valueOf(val) : result;
}

getInteger(String nm, Integer val)

返回系统属性nm的整数值,如果为空,返回默认的val。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static Integer getInteger(String nm, Integer val) {
String v = null;
try {
v = System.getProperty(nm);
} catch (IllegalArgumentException | NullPointerException e) {
}
if (v != null) {
try {
return Integer.decode(v);
} catch (NumberFormatException e) {
}
}
return val;
}

decode(String nm)

将nm解码为Integer。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public static Integer decode(String nm) throws NumberFormatException {
int radix = 10;
int index = 0;
boolean negative = false;
Integer result;

if (nm.length() == 0)
throw new NumberFormatException("Zero length string");
char firstChar = nm.charAt(0);
// Handle sign, if present
if (firstChar == '-') {
negative = true;
index++;
} else if (firstChar == '+')
index++;

// Handle radix specifier, if present
// 以'#'开头的代表十六进制???
if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
index += 2;
radix = 16;
}
else if (nm.startsWith("#", index)) {
index ++;
radix = 16;
}
// 如果0后面没有字符了,则nm就只是0而已,不是八进制。
else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
index ++;
radix = 8;
}

if (nm.startsWith("-", index) || nm.startsWith("+", index))
throw new NumberFormatException("Sign character in wrong position");

try {
result = Integer.valueOf(nm.substring(index), radix);
result = negative ? Integer.valueOf(-result.intValue()) : result;
} catch (NumberFormatException e) {
// 如果number是Integer.MIN_VALUE,由于正数最大值是Integer.MIN_VALUE-1,nm.substring(index)作为int类型的参数传入会有错误。
// 将nm.substring(index)转为负数来处理。
String constant = negative ? ("-" + nm.substring(index))
: nm.substring(index);
result = Integer.valueOf(constant, radix);
}
return result;
}

compareTo(Integer anotherInteger)

调用该方法的对象的value与参数中的对象的value相比较,this.value比anotherInteger.value小返回-1,this.value比anotherInteger.value大返回1,this.value等于anotherInteger.value返回0。

1
2
3
public int compareTo(Integer anotherInteger) {
return compare(this.value, anotherInteger.value);
}

compare(int x, int y)

比较x和y的大小,x比y小返回-1,x比y大返回1,x等于y返回0。

1
2
3
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

compareUnsigned(int x, int y)

将x,y视为无符号比较大小,因为负数符号位为1,所以正数一定比负数小。

1
2
3
public static int compareUnsigned(int x, int y) {
return compare(x + MIN_VALUE, y + MIN_VALUE);
}

toUnsignedLong(int x)

将x视为无符号转为long型。

1
2
3
public static long toUnsignedLong(int x) {
return ((long) x) & 0xffffffffL;
}

divideUnsigned(int dividend, int divisor)

将dividend和divisor视为无符号相除。

1
2
3
4
public static int divideUnsigned(int dividend, int divisor) {
// In lieu of tricky code, for now just use long arithmetic.
return (int)(toUnsignedLong(dividend) / toUnsignedLong(divisor));
}

remainderUnsigned(int dividend, int divisor)

忽略符号取dividend除以divisor的余数。

1
2
3
4
public static int remainderUnsigned(int dividend, int divisor) {
// In lieu of tricky code, for now just use long arithmetic.
return (int)(toUnsignedLong(dividend) % toUnsignedLong(divisor));
}

highestOneBit(int i)

返回十进制数转为二进制最高位表示的十进制的数值。

1
2
3
4
5
6
7
8
9
10
public static int highestOneBit(int i) {
// HD, Figure 3-1
// 使得i的二进制从排除符号位的最高位到最低位数值均为1
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
return i - (i >>> 1);
}

lowestOneBit(int i)

返回十进制数转为二进制最低位表示的十进制的数值,即忽略符号位之后最高位的数值。

1
2
3
4
public static int lowestOneBit(int i) {
// HD, Section 2-1
return i & -i;
}

numberOfLeadingZeros(int i)

i是整数,返回i的补码中最高位0的位数,从左向右数,下一位不是0的位数,范围是0~32,0代表没有。此方法很机智地采用了二分法的思想。numberOfLeadingZeros(8)=28。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static int numberOfLeadingZeros(int i) {
// HD, Figure 5-6
if (i == 0)
return 32;
int n = 1;
// 前16位上都是0,左移16位
if (i >>> 16 == 0) { n += 16; i <<= 16; }
// 前8位都是0,左移8位
if (i >>> 24 == 0) { n += 8; i <<= 8; }
// 前4位都是0,左移4位
if (i >>> 28 == 0) { n += 4; i <<= 4; }
// 前2位都是0,左移2位
if (i >>> 30 == 0) { n += 2; i <<= 2; }
// 减去第1位上数值
n -= i >>> 31;
return n;
}

numberOfTrailingZeros(int i)

i是整数,返回i的补码中最低位0的位数。从右向左数,下一位不是0的位数。numberOfLeadingZeros(8)=3。

1
2
3
4
5
6
7
8
9
10
11
public static int numberOfTrailingZeros(int i) {
// HD, Figure 5-14
int y;
if (i == 0) return 32;
int n = 31;
y = i <<16; if (y != 0) { n = n -16; i = y; }
y = i << 8; if (y != 0) { n = n - 8; i = y; }
y = i << 4; if (y != 0) { n = n - 4; i = y; }
y = i << 2; if (y != 0) { n = n - 2; i = y; }
return n - ((i << 1) >>> 31);
}

bitCount(int i)

返回i的补码中值为1的位数的个数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static int bitCount(int i) {
// 每两位存储每两位值为1的个数。
i = i - ((i >>> 1) & 0x55555555);
// 每四位存储每四位值为1的个数。
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
// 每八位存储每八位值为1的个数。
i = (i + (i >>> 4)) & 0x0f0f0f0f;
// 每十六位存储每十六位值为1的个数。
i = i + (i >>> 8);
// 每三十二位存储每三十二位值为1的个数。
i = i + (i >>> 16);
// 由于值最大为32,所以只关注后六位即可。
return i & 0x3f;
}

rotateLeft(int i, int distance)

i的二进制值循环左移distance位。普通左移会丢失最左边位数的数,但是循环左移最左边的数会循环到最右边。

1
2
3
public static int rotateLeft(int i, int distance) {
return (i << distance) | (i >>> -distance);
}

rotateRight(int i, int distance)

i的二进制值循环右移distance位。

1
2
3
public static int rotateRight(int i, int distance) {
return (i >>> distance) | (i << -distance);
}

reverse(int i)

反转i的二进制值上每一位的数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static int reverse(int i) {
// HD, Figure 7-1
// 每两个一组,每位进行反转
i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
// 每四个一组,每两位进行反转
i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
// 每八个一组,每四位进行反转
i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
// 现在有四个八组已经反转完成,标记为i=ABCD
// i << 24 D000
// (i & 0xff00) << 8 0C00
// (i >>> 8) & 0xff00 00B0
// i >>> 24 000A
i = (i << 24) | ((i & 0xff00) << 8) |
((i >>> 8) & 0xff00) | (i >>> 24);
return i;
}

signum(int i)

如果i为负数返回-1,如果i为正数返回1,如果i为0返回0。

1
2
3
4
public static int signum(int i) {
// HD, Section 2-7
return (i >> 31) | (-i >>> 31);
}

reverseBytes(int i)

反转i的二进制值的每一个字节上数。

1
2
3
4
5
6
public static int reverseBytes(int i) {
return ((i >>> 24) ) |
((i >> 8) & 0xFF00) |
((i << 8) & 0xFF0000) |
((i << 24));
}

sum(int a, int b)

返回a和b的和。

1
2
3
public static int sum(int a, int b) {
return a + b;
}

max(int a, int b)

返回a,b中的最大值。

1
2
3
public static int max(int a, int b) {
return Math.max(a, b);
}

min(int a, int b)

返回a,b中的最小值。

1
2
3
public static int min(int a, int b) {
return Math.min(a, b);
}

内部类

IntegerCache

此内部类用来缓存部分大小的Integer,默认范围-128-127。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];

static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
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;

// 缓存从low到high的整数
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);

// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}

private IntegerCache() {}
}
-------------本文结束感谢您的阅读-------------

本文标题:Java 源码--Integer

文章作者:huihui

发布时间:2018年10月29日 - 00:10

最后更新:2019年02月14日 - 19:02

原始链接:http://101.200.47.120:8011/2018/10/29/Java 源码--Integer/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。