java.lang.*中Integer 源代码详解
- 核心方法
- String toString(int i, int radix)
- String toUnsignedString(int i, int radix)
- String toHexString(int i)
- String toOctalString(int i)
- String toString(int i)
- String toUnsignedString(int i)
- int parseInt(String s, int radix)
- int parseUnsignedInt(String s, int radix)
- Integer valueOf(String s, int radix)
- public Integer(int value)
- int hashCode(int value)
- boolean equals(Object obj)
- Integer getInteger(String nm)
- Integer decode(String nm)
- int compareTo(Integer anotherInteger)
- int compareUnsigned(int x, int y)
- int divideUnsigned(int dividend, int divisor)
- int remainderUnsigned(int dividend, int divisor)
- int highestOneBit(int i)
- int lowestOneBit(int i)
- int numberOfLeadingZeros(int i)
- int numberOfTrailingZeros(int i)
- int bitCount(int i)
- int rotateLeft(int i, int distance)
- int rotateRight(int i, int distance)
- int reverse(int i)
- int signum(int i)
- int reverseBytes(int i)
学习Java的同学注意了！！！
学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！
核心方法
复制代码
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
30String toString(int i, int radix) 获取i的radix进制形式,最多36进制[OK] String toUnsignedString(int i, int radix) 获取i的radix进制字符串形式,最多36进制(不带符号位)[OK] String toHexString(int i) 获取16进制字符串结果[OK] String toOctalString(int i) 获取8进制字符串结果[OK] String toBinaryString(int i) 获取2进制字符串结果[OK] String toString(int i) 获取Integer对象的字符串形式[OK] String toUnsignedString(int i) 获取Integer对象的无符号字符串形式[OK] int parseInt(String s, int radix) 将字符串按radix进制转为int数值[OK] int parseUnsignedInt(String s, int radix) 按照radix转换无符号位字符串数值为int类型[OK] Integer valueOf(String s, int radix) 将字符串s按照radix进制,转化为int类型数值[OK] public Integer(int value) 构造方法[OK] int hashCode(int value) 获取Integer对象的HashCode值[OK] boolean equals(Object obj) 比较两个对象的值是否相等[OK] Integer getInteger(String nm) 从System.properties中获取属性值,并转为int值[OK] Integer decode(String nm) 方法解码字符串转换为整数[OK] int compareTo(Integer anotherInteger) 比较两个Integer对象的值,如果相等返回0[OK] int compareUnsigned(int x, int y) 比较两个 int值，以数值方式将值视为无符号[OK] int divideUnsigned(int dividend, int divisor) 返回将第一个参数除以秒的无符号商，其中每个参数和结果被解释为无符号值[OK] int remainderUnsigned(int dividend, int divisor) 返回无符号余数，将第一个参数除以秒，其中每个参数和结果被解释为无符号值[OK] int highestOneBit(int i) 返回一个 int值与至多一个单个1位，在最高阶（“最左侧”）的位置在指定的一个位 int值[OK] int lowestOneBit(int i) 在指定的 int值中，以最低位（最右边）为1位返回一个最多为单个1位的 int值[OK] int numberOfLeadingZeros(int i) 返回的最高阶的（“最左边的”）中所指定的二进制补码表示的一个位前述零个比特的数量 int值[OK] int numberOfTrailingZeros(int i) 返回零位以下最低阶（“最右边的”）的数量在指定的二进制补码表示的一个位 int值[OK] int bitCount(int i) 返回指定的int值的二进制补码二进制表示中的 int数[OK] int rotateLeft(int i, int distance) 返回通过旋转指定的二的补码的二进制表示而得到的值 int由位指定数目的左值[OK] int rotateRight(int i, int distance) 返回通过旋转指定的二的补码的二进制表示而得到的值 int右移位的指定数值[OK] int reverse(int i) 指定的二进制补码表示反转位的顺序而获得的值 int值[OK] int signum(int i) 返回指定的int值的signum函数[OK] int reverseBytes(int i) 返回反转指定的二进制补码表示的字节顺序而获得的值 int值[OK]
String toString(int i, int radix)
复制代码
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/** * 获取i的radix进制字符串形式,最多36进制 * 样例： * Integer.toString(-10,2) * 输出结果: * -1010 */ public static String toString(int i, int radix) { //如果radix不在[2,36]范围内时,radix默认为10进制 if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) radix = 10; /* Use the faster version */ if (radix == 10) { return toString(i); } //int最大值的2进制,再加上符号位,总共33位 char buf[] = new char[33]; boolean negative = (i < 0);//判断是否为负数 int charPos = 32; if (!negative) {//如果i为正数,将其转为负数进行进制转换 i = -i; } while (i <= -radix) {//直到i<=-radix //将i对radix取余,去对应进制表的数组中寻找对应符号 //buf[charPos--]从后往前往buf数组中插入进制符号 buf[charPos--] = digits[-(i % radix)]; //将i的值除以radix取整,作为一次循环处理逻辑 i = i / radix; } //将最后剩下的i,取到对应的符号,塞到charPos位置 buf[charPos] = digits[-i]; if (negative) {//最后根据negative符号,拼接符号位 buf[--charPos] = '-'; } //最后输出结果 return new String(buf, charPos, (33 - charPos)); }
String toUnsignedString(int i, int radix)
复制代码
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80/** * 获取i的radix进制字符串形式,最多36进制 * 样例： * Integer.toUnsignedString(-0x800000,2) * 输出结果: * 11111111100000000000000000000000 */ public static String toUnsignedString(int i, int radix) { return Long.toUnsignedString(toUnsignedLong(i), radix); } public static long toUnsignedLong(int x) { return ((long) x) & 0xffffffffL; } public static String toUnsignedString(long i, int radix) { if (i >= 0) return toString(i, radix); else { switch (radix) { case 2: return toBinaryString(i); case 4: return toUnsignedString0(i, 2); case 8: return toOctalString(i); case 10: /* * We can get the effect of an unsigned division by 10 * on a long value by first shifting right, yielding a * positive value, and then dividing by 5. This * allows the last digit and preceding digits to be * isolated more quickly than by an initial conversion * to BigInteger. */ long quot = (i >>> 1) / 5; long rem = i - quot * 10; return toString(quot) + rem; case 16: return toHexString(i); case 32: return toUnsignedString0(i, 5); default: return toUnsignedBigInteger(i).toString(radix); } } } public static String toString(long i, int radix) { if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) radix = 10; if (radix == 10) return toString(i); char[] buf = new char[65]; int charPos = 64; boolean negative = (i < 0); if (!negative) { i = -i; } while (i <= -radix) { buf[charPos--] = Integer.digits[(int)(-(i % radix))]; i = i / radix; } buf[charPos] = Integer.digits[(int)(-i)]; if (negative) { buf[--charPos] = '-'; } return new String(buf, charPos, (65 - charPos)); }
String toHexString(int i)
复制代码
1
2
3
4public static String toHexString(int i) { return toUnsignedString0(i, 4); }
String toOctalString(int i)
复制代码
1
2
3
4public static String toOctalString(int i) { return toUnsignedString0(i, 3); }
String toString(int i)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12/** * 获取Integer对象的字符串形式 */ 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); }
String toUnsignedString(int 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
38
39
40
41
42
43
44
45/** * 获取Integer对象的无符号字符串形式 */ public static String toUnsignedString(int i, int radix) { return Long.toUnsignedString(toUnsignedLong(i), radix); } public static String toUnsignedString(long i, int radix) { if (i >= 0) return toString(i, radix); else { switch (radix) { case 2: return toBinaryString(i); case 4: return toUnsignedString0(i, 2); case 8: return toOctalString(i); case 10: /* * We can get the effect of an unsigned division by 10 * on a long value by first shifting right, yielding a * positive value, and then dividing by 5. This * allows the last digit and preceding digits to be * isolated more quickly than by an initial conversion * to BigInteger. */ long quot = (i >>> 1) / 5; long rem = i - quot * 10; return toString(quot) + rem; case 16: return toHexString(i); case 32: return toUnsignedString0(i, 5); default: return toUnsignedBigInteger(i).toString(radix); } }
int parseInt(String s, int radix)
复制代码
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
61
62
63
64
65
66
67
68
69/** * 将字符串按radix进制转为int数值 * 默认是10进制 */ public static int parseInt(String s, int radix) throws NumberFormatException { /* * WARNING: This method may be invoked early during VM initialization * before IntegerCache is initialized. Care must be taken to not use * the valueOf method. */ 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) { // Accumulating negatively avoids surprises near MAX_VALUE digit = Character.digit(s.charAt(i++),radix); if (digit < 0) { throw NumberFormatException.forInputString(s); } if (result < multmin) { throw NumberFormatException.forInputString(s); } result *= radix; if (result < limit + digit) { throw NumberFormatException.forInputString(s); } result -= digit; } } else { throw NumberFormatException.forInputString(s); } return negative ? result : -result; }
int parseUnsignedInt(String s, int radix)
复制代码
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/** * 按照radix转换无符号位字符串数值为int类型 */ public static int parseUnsignedInt(String s) throws NumberFormatException { return parseUnsignedInt(s, 10); } 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 { //按照36进制,int类型的值最多存储5位 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); 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); } }
Integer valueOf(String s, int radix)
复制代码
1
2
3
4
5
6
7
8/** * 将字符串s按照radix进制,转化为int类型数值 * 底层调用的是parseInt方法 */ public static Integer valueOf(String s, int radix) throws NumberFormatException { return Integer.valueOf(parseInt(s,radix)); }
public Integer(int value)
复制代码
1
2
3
4
5
6
7
8public Integer(int value) { this.value = value; } public Integer(String s) throws NumberFormatException { this.value = parseInt(s, 10); }
int hashCode(int value)
复制代码
1
2
3
4
5
6
7
8
9
10
11/** * 获取Integer对象的hashCode值 */ public int hashCode() { return Integer.hashCode(value); } public static int hashCode(int value) { return value; }
boolean equals(Object obj)
复制代码
1
2
3
4
5
6
7
8public boolean equals(Object obj) { //首先判断obj是否为Integer类型 if (obj instanceof Integer) { return value == ((Integer)obj).intValue(); } return false; }
Integer getInteger(String nm)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22/** * 从System.properties中获取属性值,并转为int值 */ public static Integer getInteger(String nm) { return getInteger(nm, null); } 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; }
Integer decode(String nm)
复制代码
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
61
62/** * 方法解码字符串转换为整数 * 它接受十进制，十六进制和八进制数 * 样例： * System.out.println(Integer.decode("#20")); System.out.println(Integer.decode("0x20")); System.out.println(Integer.decode("0X20")); System.out.println(Integer.decode("020")); 输出结果： 32 32 32 16 */ 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; } 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) { // If number is Integer.MIN_VALUE, we'll end up here. The next line // handles this case, and causes any genuine format error to be // rethrown. String constant = negative ? ("-" + nm.substring(index)) : nm.substring(index); result = Integer.valueOf(constant, radix); } return result; }
int compareTo(Integer anotherInteger)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13/** * 比较两个Integer对象的值 * 如果相等返回0 * 如果不相等返回-1或者1 */ public int compareTo(Integer anotherInteger) { return compare(this.value, anotherInteger.value); } public static int compare(int x, int y) { return (x < y) ? -1 : ((x == y) ? 0 : 1); }
int compareUnsigned(int x, int y)
复制代码
1
2
3
4
5
6
7/** * 比较两个int值，以数值方式将值视为无符号 */ public static int compareUnsigned(int x, int y) { return compare(x + MIN_VALUE, y + MIN_VALUE); }
int divideUnsigned(int dividend, int divisor)
复制代码
1
2
3
4
5
6
7
8/** * 返回将第一个参数除以秒的无符号商，其中每个参数和结果被解释为无符号值 */ 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)); }
int remainderUnsigned(int dividend, int divisor)
复制代码
1
2
3
4
5
6
7
8/** * 返回无符号余数，将第一个参数除以秒，其中每个参数和结果被解释为无符号值 */ 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)); }
int highestOneBit(int i)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13/** * 返回一个 int值与至多一个单个1位，在最高阶（“最左侧”）的位置在指定的一个位 int值 */ public static int highestOneBit(int i) { // HD, Figure 3-1 i |= (i >> 1); i |= (i >> 2); i |= (i >> 4); i |= (i >> 8); i |= (i >> 16); return i - (i >>> 1); }
int lowestOneBit(int i)
复制代码
1
2
3
4
5
6
7
8/** * 在指定的 int值中，以最低位（最右边）为1位返回一个最多为单个1位的 int值 */ public static int lowestOneBit(int i) { // HD, Section 2-1 return i & -i; }
int numberOfLeadingZeros(int i)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16/** * 返回的最高阶的（“最左边的”）中所指定的二进制补码表示的一个位前述零个比特的数量 int值 */ public static int numberOfLeadingZeros(int i) { // HD, Figure 5-6 if (i == 0) return 32; int n = 1; if (i >>> 16 == 0) { n += 16; i <<= 16; } if (i >>> 24 == 0) { n += 8; i <<= 8; } if (i >>> 28 == 0) { n += 4; i <<= 4; } if (i >>> 30 == 0) { n += 2; i <<= 2; } n -= i >>> 31; return n; }
int numberOfTrailingZeros(int i)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15/** * 返回零位以下最低阶（“最右边的”）的数量在指定的二进制补码表示的一个位 int值 */ 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); }
int bitCount(int i)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13/** * 返回指定的int值的二进制补码二进制表示中的 int数 */ public static int bitCount(int i) { // HD, Figure 5-2 i = i - ((i >>> 1) & 0x55555555); i = (i & 0x33333333) + ((i >>> 2) & 0x33333333); i = (i + (i >>> 4)) & 0x0f0f0f0f; i = i + (i >>> 8); i = i + (i >>> 16); return i & 0x3f; }
int rotateLeft(int i, int distance)
复制代码
1
2
3
4
5
6
7/** * 返回通过旋转指定的二的补码的二进制表示而得到的值 int由位指定数目的左值 */ public static int rotateLeft(int i, int distance) { return (i << distance) | (i >>> -distance); }
int rotateRight(int i, int distance)
复制代码
1
2
3
4
5
6
7/** * 返回通过旋转指定的二的补码的二进制表示而得到的值 int右移位的指定数值 */ public static int rotateRight(int i, int distance) { return (i >>> distance) | (i << -distance); }
int reverse(int i)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13/** * 指定的二进制补码表示反转位的顺序而获得的值 int值 */ 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 = (i << 24) | ((i & 0xff00) << 8) | ((i >>> 8) & 0xff00) | (i >>> 24); return i; }
int signum(int i)
复制代码
1
2
3
4
5
6
7
8
9/** * 返回指定的int值的signum函数 * 如果指定的值为负，返回值为-1;如果指定的值为零，返回值为0;如果指定的值为正，返回值为1 */ public static int signum(int i) { // HD, Section 2-7 return (i >> 31) | (-i >>> 31); }
int reverseBytes(int i)
复制代码
1
2
3
4
5
6
7
8
9
10/* * 返回反转指定的二进制补码表示的字节顺序而获得的值 int值 */ public static int reverseBytes(int i) { return ((i >>> 24) ) | ((i >> 8) & 0xFF00) | ((i << 8) & 0xFF0000) | ((i << 24)); }
最后
以上就是着急衬衫最近收集整理的关于java.lang.*中Integer 源代码详解的全部内容，更多相关java.lang.*中Integer内容请搜索靠谱客的其他文章。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复