Java源码侦探-Integer方法解读

toUnsignedString方法解读

看到Integer中有这样的一个方法把int转为Unsigned类型的字符串，但是有几个点不是很清楚，经过查询资料弄懂了，解读如下：

 /**
     * Convert the integer to an unsigned number.
     */
    private static String toUnsignedString(int i, int shift) {
        char[] buf = new char[32];
        int charPos = 32;
        int radix = 1 << shift;
        int mask = radix - 1;
        do {
            buf[--charPos] = digits[i & mask];
            i >>>= shift;
        } while (i != 0);

        return new String(buf, charPos, (32 - charPos));
    }

这里的参数shift是代表的进制，如果是二进制的话shift是2，八进制那么就是8，相应的其mask就计算成1和7了。通过mask与i相与不断取出digits数组中对应的字符。

在就是i每次进行逻辑右移的运算，最高位补充零，这样最终经过不断的逻辑右移后i会变为0

此外，采用do-while是防止i本身是0的情况下，buf数组无法获得其值。

toString方法解读

// 这个数组表示的是数字的十位部分，下面会用到这个数组。
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',
        } ;

// 这个数组表示的是数字的个位部分，下面会用到这个数组。把数组的每个部分进行组合的话可以得到100以内的所有的情况的二位整数。

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

    public static String toString(int i) {
        if (i == Integer.MIN_VALUE)
        // 这里的加1，开始不太清楚什么意思，后来发现负数的话                           
        // 需要在前面加负号的所以串的大小要加1才行
        // 这里传入stringSize的部分是正的，在下面的数组中
        // 进行映射
        int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
        char[] buf = new char[size];
        getChars(i, size, buf);
        return new String(0, size, buf);
    }

    static void getChars(int i, int index, char[] buf) {
        int q, r;
        int charPos = index;
        char sign = 0;

        if (i < 0) {
            sign = '-';
            i = -i;
        }

        // 超过65536的整数，先进行下面这样的一个处理，
        // 这个处理中以100为单位，也就是，余数控制在两位
        // 这样正好映射到上面的十位和个位数组，一次性写入
        // buf数组中两位，这样毫无疑问比求出每一位是要快很多的
        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];
        }

        // Fall thru to fast mode for smaller numbers
        // assert(i <= 65536, i);
        // 对于小于等于65536的整数而言，可以直接进行下面的部分
        // 而且这个地方是以除以10进行的，但是实现并不是直接除
        // 而是先求一个52429/2^19约等于0.1000...
        // 相当于i除以了10，但是我不清楚的是为什么这里不直接
        // 除以10，或许是因为精度不够吧，除法产生浮点数，
        // 或许会不精确，然后得到的除数再乘以10，得到10位以上
        // 部分的数，通过i-该部分十位以上的数，得到个位的数字
        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;
        }
        if (sign != 0) {
            buf [--charPos] = sign;
        }
    }

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

    // 这里应该是进行了优化，通过sizeTable存储了整型数据的位
    // 的情况，从一位一直到10位：2147483647的情况，
    // 这个处理方式很巧妙
    static int stringSize(int x) {
        for (int i=0; ; i++)
            if (x <= sizeTable[i])
                return i+1;
    }

highestOneBit方法解读

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

这个方法很有意思，我自己算了算，然后才明白了他的精髓，这个方法的作用是求构成一个整数的最大的位所代表的整数的值。这里通过位移的方式实现了这个功能。接下来举个简单的例子，128来讲二进制是1000 0000。下面以他为例子算下：

    移1位
    1000 0000
    0100 0000
    |-------------
    移2位
    1100 0000
    0011 0000
    |------------
    移4位
    1111 0000
    0000 1111
    |------------
    移8位
    1111 1111
    0000 0000
    |------------
    移动16位
    1111 1111
    0000 0000
    |------------
    1111 1111

最终的结果如你所看到的，后面的位全部填充为1，把后面的位全部减掉就得到了最高的位代表的整数。

bitCount方法解析

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

这个方法着实废了半天功夫研究，后来算是搞懂了个大概，
第一行，实现的是把整型的二进制位进行两个两个的分组，然后统计这两个位中的1的个数，我不知道这个公式是怎么来的，但是算出来确实是这样的。
第二行，实现的是把整型的二进制位进行四个四个的分组，然后计算段内移位相加，就是1001-> 10 + 01 = 11 相当于三个1了
第三行，就是把整型的二进制位八个一组，然后类似上面的方式，进行位移相加，当然这里通过一些特定的移位以及与运算实现的。
接下来就是十六个一组，三十二个一组最终将统计数字归并到最后的几位表示的统计数值中。

reverse方法

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

这个方法看了比较长的时间，一直没找到思路，后来是结合上面的方法中用到的这几个0X55555555、0X33333333、0X0f0f0f0f,自己猜测会不会是效果和上面的类似，先两个一组，然后四个一组，然后八个一组，最后十六个一组，这样划分，不过的确是类似，这个方法的思路是两个一组然后两个位置进行调换，然后四个一组，把四个中临近的两个的位置调换，然后八个为一组，将其中四个与四个的位置进行调换，最后是按照字节的位置进行调换，后面的字节调整最高位部分，中间两个字节对换位置，原来最高位调换为最低位。