Integer三个toString()

在Integer源码中有三个toString()方法

    1、public String toString() 
    2、public static String toString(int i)
    3、public static String toString(int i, int radix)

其中1继承至object类，
完整代码为：

    public String toString() {
        return toString(value);
    }

在return会进入第2个toString方法，源码为

    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);
    }

可以看到判断

    public static final int   MIN_VALUE = 0x80000000;

    if (i == Integer.MIN_VALUE)
            return "-2147483648";

16进制的MIN_VALUE换算成10进制等于2147483648，可为什么当i==2147483648时，返回的字符串要加上负数呢？

这是因为Integer在计算机中用4个字节表示，每个字节8位，即：

00000000 00000000 00000000 00000000

其中正数范围为1~2^31，因为第一位用来表示正负符号，所以只有31位
同理负数也为1~2^31，
那么会多出两个码

00000000 00000000 00000000 00000000
10000000 00000000 00000000 00000000

其中第一个表示为0，第二个表示为-2147483648（这跟原码补码反码的知识有关，这也是Integer取值范围为-2^31 ~2^31-1的原因，负数比正数多一个值）

继续源码

        int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
        char[] buf = new char[size];
        getChars(i, size, buf);
        return new String(buf, true);

其中stringsize源码为：

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

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

它会返回参数x的位数，比如20（2位）返回2，340（3位）返回3

int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);

那么size的意图也很明显了，如果负数先转为正数，求值后+1因为要存放负号"-"

接下来进入getchar

      int charPos = index;
      while (i >= 65536) {
            q = i / 100;
        // really: r = i - (q * 100);
            r = i - ((q << 6) + (q << 5) + (q << 2));
            i = q;
            buf [--charPos] = DigitOnes[r];
            buf [--charPos] = DigitTens[r];
        }

当输入的i大于65535时会先执行这么一段方法，
举例输入为765432，则charPos=6（位数），q为7654，q << 6 则是把q放大2^6倍
((q << 6) + (q << 5) + (q << 2))即为放大q为64+32+4=100倍
则此时r=32，i等于7654
DigitOnes和DigitTens是两个设计巧妙的数组

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',
        } ;

它会把r的个位和十位取出来
此时buf 的值为：

[0，0，0，0，3，2]

接下来则继续执行

        for (;;) {
            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;
        }

其中2^19=524288, 52429/524288=0.1000003814697265
也就是q = i/10的意思，此时i为7654，则q为765
为什么不直接写i/10而要拐外抹角写这么复杂呢？这是因为乘和位移的效率在计算机运算中要比除高效，而为什么位移19位是因为19是在Interger范围内精度最接近0.1的。
类似的可以看

2^18=262144, 26215/262144  =0.10000228881835938
2^19=524288, 52429/524288  =0.1000003814697265
2^20=262144, 104858/1048576=0.1000003814697265

继续源码，r则会取出个位上的数，反复循环如此得到buf数组

r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...

最后调用return new String(buf, true)，即完成了第二个toString方法

接下来我们看第三个toString方法

public static String toString(int i, int radix)

第三个toString支持进制转换，限制为MIN_RADIX=2,MAX_RADIX=36

if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;

MIN_RADIX=2很好理解，当进制为1时没有意义，
MAX_RADIX为36则是因为数字加上26个字母一共36个，实际上可以用大写字母继续扩充，这里理解为jdk只支持到36位

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'
    };

当radix为10时，直接调用第二个toString方法

        /* Use the faster version */
        if (radix == 10) {
            return toString(i);
        }

接下来源码：

        char buf[] = new char[33];
        boolean negative = (i < 0);
        int charPos = 32;

        if (!negative) {
            i = -i;
        }

        while (i <= -radix) {
            buf[charPos--] = digits[-(i % radix)];
            i = i / radix;
        }
        buf[charPos] = digits[-i];

        if (negative) {
            buf[--charPos] = '-';
        }

我们可以知道Integer的2进制一共4*8-1为31位，算上符号也只用32位，为什么new char[33]需要33位呢？这是因为我们上面说的特殊补码

10000000000000000000000000000000

它表示的是-2147483648，而2147483648占用了32位，加上符号一共就需要32位了。

       if (!negative) {
            i = -i;
        }

这里将i统一转换成负数处理，与第二个toString不同，第二个toString是统一转换成正数处理。这里我认为统一转换成正数也可以，后续就是普通的进制转换算法。
至此，3个toString方法就全部说完了。