分享不易，喜欢请点赞支持，谢谢
JDK源码精读汇总帖
类声明
1public final class Integer extends Number implements Comparable<Integer> {} 2 3public abstract class Number implements java.io.Serializable {}
- 抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的超类。
- Number 的子类必须提供将表示的数值转换为 byte、double、float、int、long 和 short 的方法。
- Integer中对应的方法就是类型转换，将int转换成byte、double、float、long 和 short 类型。
compareTo
实现了Comparable，看看对应的方法，很好理解
1public int compareTo(Integer anotherInteger) { 2 return compare(this.value, anotherInteger.value); 3} 4 5/** 6 * jdk1.7之后单独抽取出来的static方法，可以作为工具方法用于比较两个整数 7 */ 8public static int compare(int x, int y) { 9 return (x < y) ? -1 : ((x == y) ? 0 : 1); 10}
toString(int)
看看非常常用的toString方法
1public static String toString(int i) { 2 // 如果是Integer的最小值，直接返回字符串"-2147483648" 3 if (i == Integer.MIN_VALUE) 4 return "-2147483648"; 5 // 计算形参i的位数，负数的话，size要比数字本身多1，用来存储负号(-) 6 int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i); 7 // 构造一个用于存储数字的字符数组 8 char[] buf = new char[size]; 9 // 填充字符数组 10 getChars(i, size, buf); 11 return new String(buf, true); 12}
先看看stringSize方法，这个方法返回的是形参i的位数
1final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999, Integer.MAX_VALUE }; 2 3// 要求形参x为正数 4static int stringSize(int x) { 5 // 一个个和sizeTable比较，到第i个数代表x由(i+1)个数字组成 6 for (int i=0; ; i++) 7 if (x <= sizeTable[i]) 8 return i+1; 9}
再看看getChars方法，这个方法就是将组成形成i的每一个数字，填充到buf数组里。在看getChars这个方法之前可以先思考一下，怎么样获取形参i的每个位置上的数字呢？其实就是循环：①每次除以10求余(%)，得到的就是个位上的数字；②然后再将形参i除以10，整数相除，尾数(即前面的余数)就会被丢弃；③重复①②直到形参i变成0。如12，第一次循环：除以10求余得到2，就是个位数上的数字是2，然后除以10，得到1，个位数上的2就被丢弃了，第二次循环：除10求余得到1，然后除以10得到0，于是分别得到了2和1，循环结束了。用代码来看的话就是：
1while (true) { 2 r = i % 10; 3 i /= 10; 4 // 伪代码↓ 5 // 第n次循环，将r加入到buf的倒数第n位上 6 if (i == 0) break;
以上只考虑了正数的情况，对于负数的情况，只要再循环结束后，在buf的第0个位置加上一个'-'即可，完整代码如下：
1static void myGetChars(int i, int index, char[] buf) { 2 int charPos = index;// 用来记录buf每次可插入的尾部 3 char sign = 0;// 是否为负数的标记 4 if (i < 0) { 5 sign = '-'; 6 i = -i;// 当成正数处理 7 } 8 while (true) { 9 int r = i % 10; 10 i /= 10; 11 buf [--charPos] = digits [r];// 将数字r转成字符'r'，然后添加到buf的可插入尾部 12 if (i == 0) break; 13 } 14 if (sign != 0) { 15 buf [--charPos] = sign; 16 } 17}
看样子好像实现了getChars的功能，但是jdk里面是不是这么做的呢？答案是：no!看看源码：
1static void getChars(int i, int index, char[] buf) { 2 int q, r;// r为余数，就是每次被插入到buf的数 3 int charPos = index;// buf可插入尾部 4 char sign = 0; 5 6 if (i < 0) { 7 sign = '-'; 8 i = -i; 9 } 10 11 // i >= 65536时 12 // 每次迭代向buf插入2个数字，即i的最后两位，目的应该是加快迭代速度 13 while (i >= 65536) { 14 q = i / 100; 15 // really: r = i - (q * 100); 16 // 本质就是r = i - (q * 100) 17 // q << 6 = 2^6 = 64 18 // q << 5 = 2^5 = 32 19 // q << 2 = 2^2 = 4 20 // i - q * 100 得到的r就是i的末尾2位数，本质是i%100，应该是乘法运算速度大于除法，大于求余，但是减法的速度应该也不算快 21 r = i - ((q << 6) + (q << 5) + (q << 2)); 22 i = q; 23 // 插入r的个位数 24 buf [--charPos] = DigitOnes[r]; 25 // 插入r的十位数 26 buf [--charPos] = DigitTens[r]; 27 } 28 29 // Fall thru to fast mode for smaller numbers 30 // assert(i <= 65536, i); 31 for (;;) { 32 // 这里本质就是i/10， 33 q = (i * 52429) >>> (16+3); 34 r = i - ((q << 3) + (q << 1)); // 本质就是 r = i-(q*10) 35 buf [--charPos] = digits [r];// 将数字r转成字符'r'，然后添加到buf的可插入尾部 36 i = q; 37 if (i == 0) break; 38 } 39 if (sign != 0) {// 如果是负数，再插入'-' 40 buf [--charPos] = sign; 41 } 42}
这里有几个比较有意思的地方：
- 首先是分段来获取字符，分成>=65535和<65535两段，大于等于65535的部分，每次迭代获取两个字符，这里有个疑问的地方是，为什么不分成>=10和<10两部分呢，难道是后面这一小段代码的执行速度比较快？
- 其次是<65535这部分，对于
q = (i * 52429) >>> (16+3);,这个代码等价于q = i / 10;，应该是ALU执行乘法和移位运算的速度快过除法的运算速度。但是为什么是52429和2^19 (2的19次方，无符号右移19位相当于除以2的19次方)，这是出于精度同时不会溢出这两方面考虑的。首先说精度方面，(double)52429/524288=0.100000381469，这个精度完全可以保证求出i的十分之一，比如选了一个精度不够的，求出值为0.103，那么如果i是999，999*0.103=102,并不是999的十分之一99；另外一方面，65536=2^16，52429<65536，所以i * 52429 < 2^32，不会溢出，至于i * 52429 会导致结果变成负数的问题，这只是中间结果，无符号右移19位之后，高位全部补0，结果q还是正数。
以上可以看出，jdk还是蛮严谨的，为了效率也是拼了。 - 但实际测试的结果感觉运算效率并没有很大提高，可能是以前的ALU没有现在的先进。
toString(int, int)
接下来看看toString(int i, int radix)，这个方法主要是将形参i转成radix进制的数
1public static String toString(int i, int radix) { 2 // 如果小于2进制或大于36进制，当成10进制处理 3 if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) 4 radix = 10; 5 6 /* Use the faster version */ 7 // 10进制数，直接使用更快的版本 8 if (radix == 10) { 9 return toString(i); 10 } 11 12 // Integer最多占用33位，数字32位，符号1位 13 char buf[] = new char[33]; 14 boolean negative = (i < 0);// 判断是否为负数，后面i被当成负数来统一处理 15 int charPos = 32;// buf最末尾的索引，从32开始 16 17 // 如果i是正数，取反，当成负数处理 18 if (!negative) { 19 i = -i; 20 } 21 22 // i%radix的余数的绝对值放到buf当前尾部(charPos)位置 23 while (i <= -radix) { 24 buf[charPos--] = digits[-(i % radix)]; 25 i = i / radix; 26 } 27 buf[charPos] = digits[-i]; 28 29 // 如果i是负数，加上'-' 30 if (negative) { 31 buf[--charPos] = '-'; 32 } 33 // 返回字符串，从buf的charPos位置开始截取，长度33-charPos，正好是最后一个位置，索引下标为32 34 return new String(buf, charPos, (33 - charPos)); 35}
toString()
无参的toString就没什么难度了，就是把Integer封装的value转成字符串
1public String toString() { 2 return toString(value); 3}
toHexString(int)
接下来看看几个无符号进制的转换
1public static String toHexString(int i) { 2 return toUnsignedString(i, 4); 3} 4public static String toOctalString(int i) { 5 return toUnsignedString(i, 3); 6} 7public static String toBinaryString(int i) { 8 return toUnsignedString(i, 1); 9} 10/** 11 * 本质上就是理解这个方法 12 * 因为是无符号，所以所有数字其实都可以想象成二进制的情况，如17则是0000 0000 0000 0000 0000 0001 0001 0001,-17则是1111 1111 1111 1111 1111 1111 1110 1111 13 */ 14private static String toUnsignedString(int i, int shift) { 15 // 无符号数，只需存32位即可 16 char[] buf = new char[32]; 17 // 可插入的尾部位置 18 int charPos = 32; 19 // 进制 20 int radix = 1 << shift; 21 // 类似掩码的作用，二进制是对应的是0001,八进制对应0111，十六进制对应1111 22 int mask = radix - 1; 23 do { 24 // 关键理解i & mask，整个过程就像手工转换进制一样，先得到二进制，然后每几位一组转换，如0001 0001转成8进制，每3位一组：00 010 001，然后得到0 2 1，所以17的8进制表示就是21，i & mask的过程就像分组，每次迭代将mask对应的位数得到，再利用digits转换成对应的字符 25 buf[--charPos] = digits[i & mask]; 26 i >>>= shift; 27 } while (i != 0); 28 29 return new String(buf, charPos, (32 - charPos)); 30}
演示一下i & mask的过程：
- i=17,mask=7，则相当于0001 0001 & 0111 得到001,digit[1]
=1,第二次迭代i=000 010,000 010 & 0111得到010,digit[2]=2,迭代结束，buf=21。 - i=17,mask-15，则相当于0001 0001 & 1111 得到0001,digit[1]
=1,第二次迭代i=0001,0001 & 1111得到0001,digit[1]=1,迭代结束,buf=11。
parseInt(String, int)
接着看parseInt方法，进制转换的公式：a * radix^0 + b * radix^1 + c * radix^2 + ... + xx * radix^(n-1)
1/** 2 * 整个过程的关键点都在判断下一次迭代会不会导致溢出 3 * 4 */ 5public static int parseInt(String s, int radix) 6 throws NumberFormatException 7{ 8 /* 9 * WARNING: This method may be invoked early during VM initialization 10 * before IntegerCache is initialized. Care must be taken to not use 11 * the valueOf method. 12 */ 13 14 // 下面都是判断s不能为空，进制必须在[2, 36]，可以看到jdk的源码处理也有问题，之前进制转换的，不在[2, 36]之间就当成10进制处理，现在是抛异常，规则不一样 15 if (s == null) { 16 throw new NumberFormatException("null"); 17 } 18 19 if (radix < Character.MIN_RADIX) { 20 throw new NumberFormatException("radix " + radix + 21 " less than Character.MIN_RADIX"); 22 } 23 24 if (radix > Character.MAX_RADIX) { 25 throw new NumberFormatException("radix " + radix + 26 " greater than Character.MAX_RADIX"); 27 } 28 29 // 当前的转换结果 30 int result = 0; 31 // 后面的处理都基于负数处理，一方面是统一规则，另外Integer.MIN_VALUE的绝对值比较大 32 boolean negative = false; 33 int i = 0, len = s.length(); 34 // 后面两个参数限制溢出的作用 35 int limit = -Integer.MAX_VALUE; 36 // 界定溢出，具体看下面的注释 37 int multmin; 38 // 通过Character#digit转换过来的数值 39 int digit; 40 41 if (len > 0) { 42 // 处理第一个字符 43 char firstChar = s.charAt(0); 44 if (firstChar < '0') { // Possible leading "+" or "-" 45 if (firstChar == '-') { 46 negative = true; 47 // 如果是负数，溢出标志变成Integer.MIN_VALUE 48 limit = Integer.MIN_VALUE; 49 } else if (firstChar != '+') 50 throw NumberFormatException.forInputString(s); 51 52 if (len == 1) // Cannot have lone "+" or "-" 53 throw NumberFormatException.forInputString(s); 54 i++; 55 } 56 // 界定是否溢出的标志，假设10进制最大是211，则multmin = 211 / 10 = 21，假设现在result为30，那么下一次迭代result *= radix肯定会大于211，溢出了。 57 multmin = limit / radix; 58 while (i < len) { 59 // Accumulating negatively avoids surprises near MAX_VALUE 60 // 转换函数，具体在Character类了解 61 digit = Character.digit(s.charAt(i++),radix); 62 if (digit < 0) { 63 throw NumberFormatException.forInputString(s); 64 } 65 // 因为是当成负数(limit是负数)处理，相当于正数的result > multmin 66 if (result < multmin) { 67 throw NumberFormatException.forInputString(s); 68 } 69 result *= radix;// 迭代，就是套公式a * radix^(n-1)的过程 70 // 同样是判断溢出的过程，继续上面的分析，result现在是210，如果digit是2，则转换后的result = 212，也是溢出了。 71 if (result < limit + digit) { 72 throw NumberFormatException.forInputString(s); 73 } 74 result -= digit;// 公式里相加的过程，负数的话就是减 75 } 76 } else { 77 throw NumberFormatException.forInputString(s); 78 } 79 return negative ? result : -result; 80} 81// 这个就是调用上面的方法 82public static int parseInt(String s) throws NumberFormatException { 83 return parseInt(s,10); 84}
valueOf()
接着看看valueOf方法，在看valueOf方法之前，需要先看看IntegerCache，顾名思义，这个是整数的缓存，默认情况下，IntegetCache会缓存[-128, 127]的所有实例，所以正常情况下，在这两个值范围内的对象都是相等的(==返回true)，因为它们引用的是同一块内存上的对象，有点单例的意思，当然可以通过启动参数-XX:AutoBoxCacheMax=size来修改缓存的内容(size必须大于127，否则当成127)来让jvm缓存[-size-1, size]的对象。看看代码：
1private static class IntegerCache { 2 static final int low = -128; 3 static final int high; 4 static final Integer cache[]; 5 6 static { 7 // high value may be configured by property 8 int h = 127; 9 String integerCacheHighPropValue = 10 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high"); 11 if (integerCacheHighPropValue != null) { 12 int i = parseInt(integerCacheHighPropValue); 13 i = Math.max(i, 127);// 如果配置的值比127小，缓存上界还是127 14 // Maximum array size is Integer.MAX_VALUE 15 h = Math.min(i, Integer.MAX_VALUE - (-low) -1); 16 } 17 high = h; 18 19 cache = new Integer[(high - low) + 1]; 20 int j = low; 21 // 对象一个个缓存起来，用cache数组保存 22 for(int k = 0; k < cache.length; k++) 23 cache[k] = new Integer(j++); 24 } 25 26 private IntegerCache() {} 27 }
具体看看valueOf方法
1// 调用的parseInt方法以及分析过 2public static Integer valueOf(String s, int radix) throws NumberFormatException { 3 return Integer.valueOf(parseInt(s,radix)); 4} 5public static Integer valueOf(String s) throws NumberFormatException { 6 return Integer.valueOf(parseInt(s, 10)); 7} 8public static Integer valueOf(int i) { 9 assert IntegerCache.high >= 127;// 防止IntegetCache函数上界不是127 10 // 在[IntegetCache.low, Integer.high]直接的直接从缓存中返回 11 if (i >= IntegerCache.low && i <= IntegerCache.high) 12 return IntegerCache.cache[i + (-IntegerCache.low)]; 13 return new Integer(i);// 否则新建一个实例 14}
分享不易，转载请注明出处
java.lang.Integer源码精读(一)
地址：https://www.jianshu.com/p/02c1d9092347