【Java】JDK源码分析——Integer

一.概述

Integer是int的包装类，表示4个字节以内的整型数据。
Integer.java中的相关代码：

public final class Integer extends Number implements Comparable<Integer> {
…
}

1. Integer被final修饰，不能被继承。
2.继承了Number，可以实现数值间的转换。
3.实现了Comparable<Integer>接口，可以进行Integer类型对象之间的比较。

二.源码分析

1.全局变量

Integer.java中的相关代码：

	// @Native注解修饰的变量，表示可以被Native代码引用

    // int能表示的最小的值：2的-31次方
	@Native public static final int   MIN_VALUE = 0x80000000;

	// int 能表示的最大的值：2的31次方减1
	@Native public static final int   MAX_VALUE = 0x7fffffff;

	// 抑制没有类型检查而出现的警告
	@SuppressWarnings("unchecked")
	// Integer类中对应的原始的int
	// Integer.class和int.class不相等，但Integer.TYPE和int.class相等
	public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

	// int数值转换为不同进制的字符串后可能出现的所有字符，
	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'
	};

	// 0-99数字中十位的数字，该数组在getChars方法中使用
    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',
        } ;

	// 0-99数字中个位的数字，该数组在getChars方法中使用
    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',
        } ;
    
	// 该数组表示n位数字能表示的最大值，n从1开始
	// 如：1位数字最大的是9，2位数字最大的是99…
	// 该数组在stringSize方法中使用
    final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                      99999999, 999999999, Integer.MAX_VALUE };

    // 用于保存int的数值
	private final int value;

    // int型数占的位数
	@Native public static final int SIZE = 32;

    // 一个int数占的字节
    public static final int BYTES = SIZE / Byte.SIZE;

	// 用于序列化
	@Native private static final long serialVersionUID = 1360826667806852920L;

2.静态内部类IntegerCache

该类用于提供一定范围的Integer对象的缓存。
Integer.java中的相关代码：

	private static class IntegerCache {
        static final int low = -128; // 缓存提供的最小的值：-128
        static final int high; // 缓存提供最大的值
        static final Integer cache[]; // 用于存储缓存数值的数组

        // 静态代码块初始化
        static {
            // 暂时设置缓存提供最大的值为127
            int h = 127;
            // 从虚拟机参数中读取缓存可以提供的最大值
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            // 若参数在虚拟机中存在，即不为空
            if (integerCacheHighPropValue != null) {
                try {
                    // 调用parseInt方法，将String转换为int数值
                    int i = parseInt(integerCacheHighPropValue);
                    // 和127比较，取其中最大的
                    i = Math.max(i, 127);

                    // 和Integer.MAX_VALUE - (-low) -1比较，取其中最小的
                    // 因为数组的最大长度不能超过Integer.MAX_VALUE
                    // 所以Integer.MAX_VALUE - (-low) -1表示最小值为-128时，
					// 可以取到的最大值
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            // 设置缓存提供最大的值为h
            high = h;

            // 根据最大值和最小值计算数组长度，创建数组
            cache = new Integer[(high - low) + 1];
            int j = low;
            // 循环填充数据，数组位置从0开始，数值从-128开始
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // 假设缓存的最大值大于等于127
            assert IntegerCache.high >= 127;
        }

        // 私有化构造方法
        private IntegerCache() {}
	}

3.构造方法

1）参数为int

Integer.java中的相关代码：

	public Integer(int value) {
    	// 保存到全局变量
        this.value = value;
	}

2）参数为String

Integer.java中的相关代码：

	public Integer(String s) throws NumberFormatException {
    	// 调用parseInt方法，将字符串按十进制解析成int数值
        this.value = parseInt(s, 10);
	}

4. parseInt方法

将字符串型整数解析成int型数值。
Integer.java中的相关代码：

	public static int parseInt(String s) throws NumberFormatException {
    	// 调用重载方法，按照十进制进行解析
        return parseInt(s,10);
    }

调用了重载的parseInt方法。
将指定进制的字符串型整数解析成int型的数。
Integer.java中的相关代码：

  	public static int parseInt(String s, int radix)
                throws NumberFormatException
    {
        /*
         * 注意: 在IntegerCache完成初始化之前的虚拟机初始化阶段
         * 可以使用parseInt方法，注意不要使用valueOf方法。
         */

        // 若字符串为空，则抛出异常
        if (s == null) {
            throw new NumberFormatException("null");
        }

        // 若数值的进制小于最小的进制数2，则抛出异常
        // Character.MIN_RADIX = 2
        if (radix < Character.MIN_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " less than Character.MIN_RADIX");
        }

        // 若数值的进制大于最大的进制数36，则抛出异常
        // Character.MAX_RADIX = 36
        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(); // len表示字符串长度，i为指针
        int limit = -Integer.MAX_VALUE; // 表示数值最大不能超过的范围
        int multmin; // 每次进行乘以进制数之前，不能超过的范围，超过会发生溢出
        int digit; // 用于承接字符串中每一位的数值

        // 若长度大于0
        if (len > 0) {
            // 获取首位字符
            char firstChar = s.charAt(0);
            // 小于’0’，说明可能为‘+’或‘-’
            if (firstChar < '0') {
                // 若为负号
                if (firstChar == '-') {
                    // 设置标志位为负
                    negative = true;
                    // 设置最大范围
                    limit = Integer.MIN_VALUE;
                } else if (firstChar != '+') // 若不是加号，说明为其它字符，则抛出异常
                    throw NumberFormatException.forInputString(s);

                //若长度为1，说明只有符号，没有数值，则抛出异常
                if (len == 1)
                    throw NumberFormatException.forInputString(s);
                // 指针指向下一位
                i++;
            }
            // 计算乘以进制数前数值的最大范围
            multmin = limit / radix;

            // 计算方法：对不同进制的字符串，先用result乘以字符串本身的进制，
            // 1）用result乘以字符串本身的进制数，保存到result中
            // 2）从前向后依次取字符串中的字符，转换为十进制对应的数值，
			//    累加到result上
			// 3）循环执行1）和2），遍历所有字符，最后的结果就是对应的int型数。
			// 同时为了防止在最大值出发生意外，采用负向累加的方法
			// 即：对于正数，每次减去字符表示的数值，再乘以进制数，最后进行
			// 符号调整。负数每次加上字符表示的数值，再乘以进制数，因为是负数，
			// 所以最后不调整符号。

			// 循环
            while (i < len) {
                // 获取字符，指针指向下一位
                // 调用Character的digit方法
                // 该方法会返回在指定进制下字符表示的十进制数
                digit = Character.digit(s.charAt(i++),radix);
                // 若返回的数小于0，则抛出异常
                if (digit < 0) {
                    throw NumberFormatException.forInputString(s);
                }
                // 若超过乘以进制数前数值的最大范围
                // 说明乘以进制数后会溢出，因此抛出异常
                // 因为两个数都是负数，所以用<比较
                if (result < multmin) {
                    throw NumberFormatException.forInputString(s);
                }
                // 乘以进制数，并保存到result中
                result *= radix;

                // 预先判断rusult减去字符对应的十进制数后会不会
                // 超过最大值范围，超过则抛异常。
                // 正常因该为result-digit<limit，为了防止result-digit溢出
                // 所以digit移到了右边
                if (result < limit + digit) {
                    throw NumberFormatException.forInputString(s);
                }
                // 减去digit，因为result为负数，所以相当于反向增大
                result -= digit;
            }
        } else { // 若字符串长度等于0，则抛出异常
            throw NumberFormatException.forInputString(s);
        }
        // 若是负数，直接返回，若是正数，则调整符号再返回
        return negative ? result : -result;
	}

5. parseUnsignedInt方法

将String按照无符号十进制整数进行解析。
Integer.java中的相关代码：

	public static int parseUnsignedInt(String s) throws NumberFormatException {
    	// 调用了重载方法，按照十进制进行解析
        return parseUnsignedInt(s, 10);
	}

调用了重载的parseUnsignedInt方法。
将指定进制的字符串型无符号整数解析成int型的数。
Integer.java中的相关代码：

    public static int parseUnsignedInt(String s, int radix)
                throws NumberFormatException {
        // 若字符串为空，则抛出异常
        if (s == null)  {
            throw new NumberFormatException("null");
        }

        // 获取字符串长度
        int len = s.length();
        // 若长度大于0
        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 {// 若不是减号
                // 先判断符号位是否被占用
				// 即是否可以按照有符号情况的处理

                // 若长度小于等于5或十进制下长度小于等于9
                // 小于等于5是因为在int的数值范围内同时不占用符号位
				// 只能有5个最大进制——36进制的字符
				// 如果为10进制，满足范围要求和不占用符号位条件下
				// 只能有9个十进制的字符
                if (len <= 5 || (radix == 10 && len <= 9) ) {
                    // 满足要求，可以按有符号情况进行处理
                    // 调用parseInt处理 
                    return parseInt(s, radix);
                } else { // 若不能按照有符号数进行处理
                    // 调用Long的parseLong处理
                    long ell = Long.parseLong(s, radix);
                    // 若高32位为0，说明没有超过int的32位范围
                    if ((ell & 0xffff_ffff_0000_0000L) == 0) {
                        // 进行类型转换，返回
                        return (int) ell;
                    } else { // 若高32位不为0，说明有溢出，则抛出异常
                        throw new
                            NumberFormatException(String.format("String value %s exceeds " +"range of unsigned int.", s));
                    }
                }
            }
        } else { // 长度小于等于0，则抛出异常
            throw NumberFormatException.forInputString(s);
        }
    }

6. valueOf方法

将String类型的数转换为Integer对象。

1）参数为String

指定进制数：

Integer.java中的相关代码：

	public static Integer valueOf(String s, int radix) throws NumberFormatException {
    	// 调用parseInt解析成int数值
    	// 再调用重载方法，对int数值包装成Integer对象
        return Integer.valueOf(parseInt(s,radix));
	}

不指定进制数：

Integer.java中的相关代码：

	public static Integer valueOf(String s) throws NumberFormatException {
    	// 调用parseInt解析成int数值，默认10进制
    	// 再调用重载方法，对int数值包装成Integer对象
        return Integer.valueOf(parseInt(s, 10));
    }

2）参数为int

Integer.java中的相关代码：

	public static Integer valueOf(int i) {
    	// 若参数满足缓存的数值范围
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            // 在缓存中查找，返回
            return IntegerCache.cache[i + (-IntegerCache.low)];
        // 缓存中没有，则创建新对象，返回
        return new Integer(i);
    }

7. byteValue方法

获取当前数值对应的byte型数值。
Integer.java中的相关代码：

	public byte byteValue() {
    	// 类型转换，返回
        return (byte)value;
    }

8. shortValue方法

获取当前数值对应的short型数值。
Integer.java中的相关代码：

	public short shortValue() {
    	// 类型转换，返回
        return (short)value;
    }

9. intValue方法

获取当前数值对应的int型数值。
Integer.java中的相关代码：

	public int intValue() {
    	// 直接返回
        return value;
    }

10. longValue方法

获取当前数值对应的long型数值。
Integer.java中的相关代码：

	public long longValue() {
    	// 类型转换，返回
        return (long)value;
    }

11. floatValue方法

获取当前数值对应的float型数值。
Integer.java中的相关代码：

	public float floatValue() {
    	// 类型转换，返回
        return (float)value;
    }

12. doubleValue方法

获取当前数值对应的double型数值。
Integer.java中的相关代码：

	public double doubleValue() {
    	// 类型转换，返回
        return (double)value;
    }

13. toString方法

将Integer对象转换为String对象。

1）无参数

Integer.java中的相关代码：

	public String toString() {
    	// 调用重载方法
        return toString(value);
    }

2）参数为int

只能将数值转换为十进制表示的字符串。
Integer.java中的相关代码：

	public static String toString(int i) {
    	// 若为最小值，直接返回"-2147483648"
        if (i == Integer.MIN_VALUE)
            return "-2147483648";
        // 调用stringSize方法获取数字的长度
        // 小于0时，因为有负号，所以加一
        // 详解在a）处
        int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
        // 根据长度创建字符数组
        char[] buf = new char[size];
        // 调用getChars方法，对字符数组进行填充
        // 详解在b）处
        getChars(i, size, buf);
        // 根据字符数组的内容，创建新的字符串
        return new String(buf, true);
	}

a）stringSize方法

获取一个数字的长度。
Integer.java中的相关代码：

	static int stringSize(int x) {
    	// 循环，判断该数是否i位数的最大值
        for (int i=0; ; i++)
            // 若该数大于i位数的最大值
            if (x <= sizeTable[i])
                // 因为i是从0开始，但没有0位数，
				// 数字最少1位，所以要加1。
                return i+1;
	}

b）getChars方法

该方法用于将数字填充到字符数组中。
Integer.java中的相关代码：

	static void getChars(int i, int index, char[] buf) {
        int q, r; // q，r用于承接个位、十位、百位、千位…的数字
        int charPos = index; // 指针，从后向前填充字符数组
        char sign = 0; // 用于保存数字的符号

        // 若数值小于0
        if (i < 0) {
            // 设置符号为负号
            sign = '-';
            // 将负数变成正数
            i = -i;
        }

        // 对于大于65536的数
        // 先通过迭代，每次向字符数组中填充两个字符
        while (i >= 65536) {
            q = i / 100;
            // 该操作实际效果等同于r = i - (q * 100);
            // r实际上就是数值的后两位
            r = i - ((q << 6) + (q << 5) + (q << 2));
            // i此时变成了去除了后两位数字的数
            i = q;
            // 从数组中查找，填充字符数组，指针向前移动
            buf [--charPos] = DigitOnes[r];
            buf [--charPos] = DigitTens[r];
        }

        // 对于小于65536的数字
		// 每次向字符数组中填充一个字符
        for (;;) {
            // 该操作相当于q = i /10;
            q = (i * 52429) >>> (16+3);
            // 该操作相当于r = i-(q*10);
            r = i - ((q << 3) + (q << 1));
            // 经过上面两部操作，r的值为i的最后一位
            // 查找数组，填充字符数组，指针向前移动
            buf [--charPos] = digits [r];
            // 此时i变为去除最后一位数字的数
            i = q;
            // 若i为0，说明没有数字可以填充，跳出循环
            if (i == 0) break;
        }
        // 若sign不为0,说明为负数
        if (sign != 0) {
            // 填充负号
            buf [--charPos] = sign;
        }
	}

3）参数为int

支持将数值转换为不同进制表示的字符串。
Integer.java中的相关代码：

	public static String toString(int i, int radix) {
    	// 若进制数大于最大进制数36或小于最小进制数2
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            // 则默认进制数为10
            radix = 10;

        // 若进制为10
        if (radix == 10) {
            // 调用重载的toString方法处理
            return toString(i);
        }

        // 创建字符数组
        // 长度最长时为二进制情况下，共32位，因为可能有负号
        // 所以加1，共33位
        char buf[] = new char[33];
        // 标志位，用于判断数值的正负
        boolean negative = (i < 0);
        // 指针，从后向前
        int charPos = 32;

        // 若为正数，则将正值变成负值
        // 这样处理，可以防止正向溢出
        if (!negative) {
            i = -i;
        }

        // 当负的数值小于等于负的进制数
        while (i <= -radix) {
            // i除以radix取余，再将余数变成正数，查找数组
            // 填充到字符数组，指针向前移动
            buf[charPos--] = digits[-(i % radix)];
            // 实际效果相当于去掉i小于进制数radix的部分
            i = i / radix;
        }
        // 填充最后一个字符
        buf[charPos] = digits[-i];
 
        // 若为负数
        if (negative) {
            // 填充负号，指针向前移动
            buf[--charPos] = '-';
        }

        // 根据字符数组的内容和长度，创建新字符串
        return new String(buf, charPos, (33 - charPos));
	}

14. hashCode方法

获取当前对象的哈希值。
Integer.java中的相关代码：

    @Override
	public int hashCode() {
    	// 调用静态方法hashCode
        return Integer.hashCode(value);
	}

调用静态方法hashCode。
Integer.java中的相关代码：

	public static int hashCode(int value) {
    	// 直接返回数值
        return value;
	}

15. equals方法

比较两个Integer对象的值是否相等。
Integer.java中的相关代码：

	public boolean equals(Object obj) {
    	// 若为Integer对象
        if (obj instanceof Integer) {
            // 比较两个对象的值是否相等
            return value == ((Integer)obj).intValue();
        }
        // 若不是Integer对象，返回false
        return false;
    }

16. getInteger方法

从系统变量中读取Integer数值。

1）不指定默认值

Integer.java中的相关代码：

	public static Integer getInteger(String nm) {
    	// 调用重载方法，若获取不到，则返回为空
    	// 详解在3）处
        return getInteger(nm, null);
    }

2）指定默认值

Integer.java中的相关代码：

	public static Integer getInteger(String nm, int val) {
    	// 调用重载方法，若获取不到，则返回为空
    	// 详解在3）处
        Integer result = getInteger(nm, null);
        // 若返回值为空，则将默认值包装成Integer对象，返回
        // 若返回值不为空，则直接返回
        return (result == null) ? Integer.valueOf(val) : result;
	}

3）重载的getInteger方法

Integer.java中的相关代码：

	public static Integer getInteger(String nm, Integer val) {
    	// 用于保存获取的系统变量
        String v = null;
        try {
            // 获取系统变量
            v = System.getProperty(nm);
        } catch (IllegalArgumentException | NullPointerException e) {
        }
        // 若系统变量不为空
        if (v != null) {
            try {
                // 将系统变量进行解码成Integer对象，返回
                return Integer.decode(v);
            } catch (NumberFormatException e) {
            }
        }
        // 若系统变量不存在，则返回默认值
        return val;
	}

17. decode方法

将字符串解码成Integer对象。
该方法支持带有进制标识符(如：0x，#)的8、10、16进制的字符串，但是字符串中不能有空格。
Integer.java中的相关代码：

	public static Integer decode(String nm) throws NumberFormatException {
    	// 默认进制为10
        int radix = 10;
        // 指针从0开始
        int index = 0;
        // 判断正负数的标志位，默认正数
        boolean negative = false;
        // 用于保存解码后的结果
        Integer result;

        // 若长度为0，抛出异常
        if (nm.length() == 0)
            throw new NumberFormatException("Zero length string");
        // 获取首位字符
        char firstChar = nm.charAt(0);
        // 若为负号
        if (firstChar == '-') {
            // 设置标志位，指针向后移动
            negative = true;
            index++;
        // 若为正号
        } else if (firstChar == '+')
            // 指针向后移动
            index++;

        // 对进制标识符进行处理
        // 若以“0x”或“0X”开头
        if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
            // 指针后移两位
            index += 2;
            // 设置进制为16进制
            radix = 16;
        } // 若以“#”开头
        else if (nm.startsWith("#", index)) {
            // 指针向后移动
            index ++;
            // 设置进制为16进制
            radix = 16;
        } // 若以“0”开头，同时不是只有一个0
        else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
            // 指针向后移动
            index ++;
            // 设置进制为8进制
            radix = 8;
        }

        // 若在进制标识符后出现正负号，则抛出异常
        if (nm.startsWith("-", index) || nm.startsWith("+", index))
            throw new NumberFormatException("Sign character in wrong position");

        try {
            // 截取数值部分，调用valueOf方法进行解析
            result = Integer.valueOf(nm.substring(index), radix);
            // 对数值的正负进行调整
            result = negative ? Integer.valueOf(-result.intValue()) : result;
        } catch (NumberFormatException e) {
            // 若数值为Integer.MIN_VALUE，将发生异常
			// 因为Integer的最大负值的绝对值比最大正值的绝对值大1
			// 若为负数，把负号拼接到数值前面
            String constant = negative ? ("-" + nm.substring(index))
                                       : nm.substring(index);
            // 调用valueOf方法进行解析
            result = Integer.valueOf(constant, radix);
        }
        // 返回
        return result;
    }

18. compare方法

比较两个int数值。
Integer.java中的相关代码：

	public static int compare(int x, int y) {
    	// 若x小于y，则返回-1。
		// 若x大于y，则返回1。
		// 若x等于y，则返回0。
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

19. compareTo方法

比较两个Integer数值。
若相等则返回0，若小于anotherInteger则返回-1，若大于anotherInteger则返回1。
Integer.java中的相关代码：

	public int compareTo(Integer anotherInteger) {
    	// 调用compare方法
        return compare(this.value, anotherInteger.value);
	}

20. compareUnsigned方法

比较两个无符号数。
若x等于y则返回0，若x小于y则返回一个小于0的数，若x大于y则返回一个大于0的数。
Integer.java中的相关代码：

	public static int compareUnsigned(int x, int y) {
    	// 调用compare方法
    	// 加上MIN_VALUE，占用符号位，变成无符号整数
        return compare(x + MIN_VALUE, y + MIN_VALUE);
    }

21. toUnsignedLong方法

将int数变成无符号long型数。
Integer.java中的相关代码：

	public static long toUnsignedLong(int x) {
    	// 类型转换，和掩码进行与运算，让该是1的是1，该是0的是0
        return ((long) x) & 0xffffffffL;
    }

22. highestOneBit方法

在数值i的二进制表示中，除去符号位，从高到低找到第一个为1的位置p，返回数值为2的(p-1)次方。如果数值i的二进制表示中除去符号位没有1，则返回0。
Integer.java中的相关代码：

	public static int highestOneBit(int i) {
    	i |= (i >>  1);
    	i |= (i >>  2);
    	i |= (i >>  4);
    	i |= (i >>  8);
    	i |= (i >> 16);
    	return i - (i >>> 1);
	}

23. lowestOneBit方法

在数值i的二进制表示中，除去符号位，从低到高找到第一个为1的位置p，返回数值为2的(p-1)次方。如果数值i的二进制表示中除去符号位没有1，则返回0。
Integer.java中的相关代码：

	public static int lowestOneBit(int i) {
    	return i & -i;
	}

24. numberOfLeadingZeros方法

获取数值i的二进制表示下，前导零的数量。
Integer.java中的相关代码：

	public static int numberOfLeadingZeros(int i) {
    	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;
	}

25. numberOfTrailingZeros方法

获取数值i的二进制表示下，后补零的数量。
Integer.java中的相关代码：

	public static int numberOfTrailingZeros(int i) {
        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);
    }

26. bitCount方法

获取数值i的二进制表示中1的数量。
Integer.java中的相关代码：

	public static int bitCount(int i) {
        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;
    }

27. rotateLeft方法

将数值i在二进制表示下循环左移distance位。
Integer.java中的相关代码：

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

28. rotateRight方法

将数值i在二进制表示下循环右移distance位。
Integer.java中的相关代码：

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

29. reverse方法

将数值i在二进制表示下位的顺序反转，即原来的从高到低变成从低到高。
Integer.java中的相关代码：

	public static int reverse(int i) {
        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;
    }

30. signum方法

该方法表示一个符号函数，i大于0返回1，i小于0返回-1，i等于0返回0。
Integer.java中的相关代码：

	public static int signum(int i) {
        return (i >> 31) | (-i >>> 31);
    }

31. reverseBytes方法

将数值i在二进制表示下，按字节将位的顺序反转，即每8位一反转。
Integer.java中的相关代码：

	public static int reverseBytes(int i) {
        return ((i >>> 24)           ) |
               ((i >>   8) &   0xFF00) |
               ((i <<   8) & 0xFF0000) |
               ((i << 24));
    }

32. sum方法

将两个int数值相加。
Integer.java中的相关代码：

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

33. max方法

获取两个int数值中的最大的数。
Integer.java中的相关代码：

	public static int max(int a, int b) {
    	// 调用Math的max方法
        return Math.max(a, b);
    }

34. min方法

获取两个int数值中的最小的数。
Integer.java中的相关代码：

	public static int min(int a, int b) {
    	// 调用Math的min方法
        return Math.min(a, b);
    }

35. toUnsignedString方法

将无符号整型数转换为字符串。
Integer.java中的相关代码：

	public static String toUnsignedString(int i, int radix) {
    	// 先将无符号整型数转换成无符号长整型数
    	// 再调用Long的toUnsignedString方法转换成字符串
        return Long.toUnsignedString(toUnsignedLong(i), radix);
    }

36. toUnsignedString0方法

该方法是一个私有方法，该方法会将数值val的二进制表示中，从低到高，每shift位一组读取成对应字符，是Integer中很多方法实现的基础。
Integer.java中的相关代码：

	private static String toUnsignedString0(int val, int shift) {
        // 用int总位数减去数值val的前导零个数
        // mag为数值二进制中的有效位数
        int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
        // 计算转换后字符串的长度
        int chars = Math.max(((mag + (shift - 1)) / shift), 1);
        // 创建字符数组
        char[] buf = new char[chars];

        // 填充字符数组
        // 详解在1）处
        formatUnsignedInt(val, shift, buf, 0, chars);

        // 根据字符数组的内容，创建字符串，返回
        return new String(buf, true);
	}

1）formatUnsignedInt方法

Integer.java中的相关代码：

	static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
        // 指针，从后向前
        int charPos = len;
        // 计算进制数
        int radix = 1 << shift;
        // 计算掩码
        // 如：16进制时掩码为15，对应二进制为0000 1111B，
		// 和掩码进行与运算只会保留低四位，故称为掩码
        int mask = radix - 1;
        // 循环 当val不为0同时指针没有到头
        do {
            // 与掩码进行与运算，相当于取最后的shift位对应的值
            // 查找digit数组，填充到字符数组buf中，同时指针向前移动
            buf[offset + --charPos] = Integer.digits[val & mask];
            // 右移，为了下一次获取最后shift位数值
            val >>>= shift;
        } while (val != 0 && charPos > 0);

        // 返回
        return charPos;
    }

37. toHexString方法

将int数值转换为十六进制表示的字符串。
Integer.java中的相关代码：

	public static String toHexString(int i) {
    	// 调用toUnsignedString0方法，四位一组
        return toUnsignedString0(i, 4);
    }

38. toOctalString方法

将int数值转换为八进制表示的字符串。
Integer.java中的相关代码：

	public static String toOctalString(int i) {
	    // 调用toUnsignedString0方法，三位一组
        return toUnsignedString0(i, 3);
    }

39. toBinaryString方法

将int数值转换为二进制表示的字符串。
Integer.java中的相关代码：

	public static String toBinaryString(int i) {
    	// 调用toUnsignedString0方法，一位一组
        return toUnsignedString0(i, 1);
    }