Integer源码解读(JDK8)

//八大基本数据类型：byte、int、short、long、double、float、boolean、char
//八大包装类型：Byte、Integer、Short、Long、Double、Float、Boolean、Character
//包装类都是被final修饰的,不可以被继承(由于被final修饰)
//继承Number
//实现了比较接口(需要重写compareTo方法)
//继承于Number类(该类继承了Serializable(序列化)接口),需要重写各种xxxValue方法
//Number类是java.lang包下的一个抽象类,提供了将包装类型拆箱成基本类型的方法，所有基本类型的包装类型都继承了该抽象类，并且包装类都用final修饰为不可继承类
//xxxValue方法就是转换成对应的类型
//自动装箱也就是调用了Integer类的一个静态方法valueOf方法(该方法返回Integer对象)
public final class Integer extends Number implements Comparable {

    //最小值常量(十六进制补码形式表示):-231
    @Native
    public static final int MIN_VALUE = 0x80000000;

    //最大值常量(十六进制补码形式表示):231-1
    @Native
    public static final int MAX_VALUE = 0x7fffffff;

    //常量TYPE保存了当前包装类的对应的基本数据类型的Class实例
    //getPrimitiveClass----native方法
    @SuppressWarnings("unchecked")
    public static final Class TYPE = (Class) Class.getPrimitiveClass("int");

    //digits数组常量：表示数字的所有可能的字符，int支持二进制到三十六进制(故需要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'
    };

    /**
     * 静态toString方法转化对应进制的数字为十进制
     * @param i         整型的数字
     * @param radix     该数字的进制
     * @return           返回一个字符串
     */
    public static String toString(int i, int radix) {
        //若输入的进制不在二到三十六进制之间，则直接当十进制处理
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;

        //为十进制时,调用另一个静态方法直接输出
        if (radix == 10) {
            return toString(i);
        }

        //创建一个33位的字符数组(负数时:1位符号位+32位数字；正数时,32位数字)
        char buf[] = new char[33];
        //判断当前数字的正负性
        boolean negative = (i < 0);
        int charPos = 32;

        //将正数转为负数进行运算，防止负数转为正数的溢出情况
        if (!negative) {
            i = -i;
        }

        //循环到i小于进制的负数
        //根据余数通过digits数组取到对应的字符，然后存到char数组即可。
        while (i <= -radix) {
            //
            buf[charPos--] = digits[-(i % radix)];
            i = i / radix;
        }

        buf[charPos] = digits[-i];

        //若是负数，加上'-'符
        if (negative) {
            buf[--charPos] = '-';
        }

        //创建一个字符串   char数组、起始位置、字符总数
        return new String(buf, charPos, (33 - charPos));
    }

    //将某进制的int类型数字转为long类型数字，最后转为String类型返回
    public static String toUnsignedString(int i, int radix) {
        return Long.toUnsignedString(toUnsignedLong(i), radix);
    }

    //转为十六进制字符串
    //底层采用toUnsignedString()方法
    public static String toHexString(int i) {
        //shift为2的多少次方
        return toUnsignedString0(i, 4);
    }

    //转为八进制字符串
    //底层采用toUnsignedString()方法
    public static String toOctalString(int i) {
        return toUnsignedString0(i, 3);
    }

    //转为二进制字符串
    //底层采用toUnsignedString()方法
    public static String toBinaryString(int i) {
        return toUnsignedString0(i, 1);
    }

    /**
     * 将整型对象转为一个无符号的数字
     * @param val
     * @param shift
     * @return
     */
    private static String toUnsignedString0(int val, int shift) {
        // assert shift > 0 && shift <=5 : "Illegal shift value";
        //
        int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
        int chars = Math.max(((mag + (shift - 1)) / shift), 1);
        char[] buf = new char[chars];

        formatUnsignedInt(val, shift, buf, 0, chars);

        // Use special constructor which takes over "buf".
        return new String(buf, true);
    }
    
    /**
     *填充字符数组
     * @param val
     * @param shift
     * @param buf
     * @param offset
     * @param len
     * @return
     */
    static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
        int charPos = len;
        int radix = 1 << shift;
        int mask = radix - 1;
        do {
            buf[offset + --charPos] = java.lang.Integer.digits[val & mask];
            val >>>= shift;
        } while (val != 0 && charPos > 0);

        return charPos;
    }

    /**
     * DigitTens和DigitOnes这两个常量数组主要是为了获取0到99之间某个数的十位和个位。
     */
    //取十位数
    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',
    };

    /**
     * 静态toString方法
     * @param i    一个被转化的int值
     * @return
     */
    public static String toString(int i) {
        //如果最小的情况
        if (i == Integer.MIN_VALUE)
            //返回-2^31
            return "-2147483648";
        //将负数取反为正数，然后计算数字是多少位的
        int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
        //创建对应数字位数的char数组
        char[] buf = new char[size];
        //将数字分成一个个char，保存到buf数组中
        getChars(i, size, buf);
        //该String构造函数,直接将传入的参数数组的引用给了内部数组，节省时间，共享内部数组节约内存，不像String(char [] buf)构造函数，使用Arrays.copyOf()方法重新创建一个char数组对象
        return new String(buf, true);
    }

    //将int类型的数字转为Long无符号类型，然后将Long类型转为String类型
    public static String toUnsignedString(int i) {
        return Long.toString(toUnsignedLong(i));
    }

    //将某个int型数值写入到字符数组中（若i等于Integer.MIN_VALUE,则为失败）
    //该方法将int进行高两字节、低两字节分开处理
    //几种运算的耗时长短:除法运算>乘法运算>移位结合加法的运算
    //index一般为数的长度
    static void getChars(int i, int index, char[] buf) {
        int q, r;
        //字符的位置
        int charPos = index;
        char sign = 0;

        //如果i为负数,则将负数标志置为-
        //然后将i取反，将负号去掉，取数值部分
        if (i < 0) {
            sign = '-';
            i = -i;
        }

        // Generate two digits per iteration
        //处理高两字节
        while (i >= 65536) {
            //处理两位
            q = i / 100;
            // really: r = i - (q * 100);
            r = i - ((q << 6) + (q << 5) + (q << 2));
            //将商赋给i，继续循环，直到小于65536
            i = q;
            //取DigitOnes[r]的值其实取数字r%10的结果
            buf[--charPos] = DigitOnes[r];
            //取DigitTens[r]的值其实取数字r/10的结果
            buf[--charPos] = DigitTens[r];
        }

        // Fall thru to fast mode for smaller numbers
        // assert(i <= 65536, i);
        //循环存放低两字节的数字存放到字符数组中空余位置
        for (; ; ) {
            //右移19位
            /**
             * >>>: 无符号的右移
             * >>: 有符号的右移
              */
            //q=i/10
            q = (i * 52429) >>> (16 + 3);
            //r = i-(q*10)
            r = i - ((q << 3) + (q << 1));
            //从digit数组中取数
            buf[--charPos] = digits[r];
            i = q;
            //整数写入字符数组完成
            if (i == 0) break;
        }
        //若整数是负数，需要在字符数组中加上'-'字符
        if (sign != 0) {
            buf[--charPos] = sign;
        }
    }

    //用在判断一个int类型数字对应字符串的长度
    final static int[] sizeTable = {9, 99, 999, 9999, 99999, 999999, 9999999,
            99999999, 999999999, java.lang.Integer.MAX_VALUE};  //最大值位数为10位

    // Requires positive x
    //判断int型数字对应字符串的长度(不使用除法或求余等操作,和对应值来比较得到具体的位数)
    static int stringSize(int x) {
        for (int i = 0; ; i++)
            if (x <= sizeTable[i])
                return i + 1;
    }

    /**
     *
     * @param s          待转换的字符串
     * @param radix      当前字符串的数字部分的进制数(也就是s的进制)
     * @return            返回十进制的数
     * @throws NumberFormatException
     * 该方法使用负数进行运算(原因：Integer.MIN_VALUE变为正数时大于Integer.MAX_VALUE，会导致数值溢出)
     */
    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.
         */
        //NumberFormatException:将一个字符串转为数字类型，该字符串不能有一个适当地转化结果，而抛出该异常
        //字符串不为空
        if (s == null) {
            throw new NumberFormatException("null");
        }

        //字符串的进制最少为二进制
        if (radix < Character.MIN_RADIX) {
            throw new NumberFormatException("radix " + radix +
                    " less than Character.MIN_RADIX");
        }

        //字符串的进制最大为36进制
        if (radix > Character.MAX_RADIX) {
            throw new NumberFormatException("radix " + radix +
                    " greater than Character.MAX_RADIX");
        }

        //保存转化结果
        int result = 0;
        //当前数是否为负数
        boolean negative = false;
        //i表示当前的转化的字符串的下标
        int i = 0, len = s.length();
        //判断值----正数情况下使用(默认情况)
        int limit = -java.lang.Integer.MAX_VALUE;
        int multmin;
        int digit;

        //字符串长度大于0
        if (len > 0) {
            //根据第一个字符判断当前字符串的正负
            //获取字符串的第一个字符
            char firstChar = s.charAt(0);
            //第一个字符小于0的情况
            if (firstChar < '0') { // Possible leading "+" or "-"
                //负数
                if (firstChar == '-') {
                    negative = true;
                    //限制值
                    limit = java.lang.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
                //将字符串的数字部分的一个数字(对应进制)，通过Character类转为十进制的数
                //若字符串中的某一个字符，在字符串进制下(radix)是无效的，则返回-1
                digit = Character.digit(s.charAt(i++), radix);
                //若返回-1(无效)
                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;
    }

    //默认情况下字符串中的数字是十进制的(也就是radix是十进制)
    public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s, 10);
    }

    /**
     * 字符串转为无符号的整型数
     * @param s        原字符串
     * @param radix    原字符串的进制
     * @return         返回int类型的数字
     * @throws NumberFormatException
     */
    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 {    //
                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类型数据(radix进制)
                    long ell = Long.parseLong(s, radix);
                    //只有低4字节有数,则强转为4字节的int类型，然后输出
                    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);
        }
    }

    //径字符串转为无符号整数，该方法默认字符串中数字为十进制
    public static int parseUnsignedInt(String s) throws NumberFormatException {
        return parseUnsignedInt(s, 10);
    }

    //将某进制的字符串转为int类型的数字
    public static java.lang.Integer valueOf(String s, int radix) throws NumberFormatException {
        return java.lang.Integer.valueOf(parseInt(s, radix));
    }

    public static java.lang.Integer valueOf(String s) throws NumberFormatException {
        //将传入的字符串按照十进制转化为int类型数字，然后调用valueOf(int i)静态方法获得
        return java.lang.Integer.valueOf(parseInt(s, 10));
    }

    //代码执行优先级：静态代码块(一个类)>代码块>构造函数
    //内部类IntegerCache类 ------ 包含了int可能值的Integer数组,默认范围是-128到127，所以这里就默认只实例化256个Integer对象(在该范围内时,则直接从缓存中获取对应的Integer对象，不必重新实例化)
    //
    private static class IntegerCache {
        static final int low = -128;
        //高值可以通过属性配置:启动JVM时通过 -Djava.lang.Integer.IntegerCache,high=xxx进行设置
        static final int high;
        static final java.lang.Integer cache[];
        //
        static {
            // high value may be configured by property
            int h = 127;
            //读取JVM启动时的缓存值的最大值配置
            String integerCacheHighPropValue =
                    sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, java.lang.Integer.MAX_VALUE - (-low) - 1);
                } catch (NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            //未配置则为默认最高值127
            high = h;

            //创建一个大小为(最大值-最小值+1)的数组
            cache = new java.lang.Integer[(high - low) + 1];
            int j = low;
            //创建对应大小的Integer对象,放入缓存的数组中
            for (int k = 0; k < cache.length; k++)
                cache[k] = new java.lang.Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            //保证Integer缓存最大值必须大于等于127(该断言在发现缓存最大值小于127时，会抛出AssertionError)
            assert java.lang.Integer.IntegerCache.high >= 127;
        }

        private IntegerCache() {
        }
    }

    //该方法直接获得在[low,high]范围内的IntegerCache缓存的Integer对象，不在该范围则重新实例化Integer对象
    public static java.lang.Integer valueOf(int i) {
        if (i >= java.lang.Integer.IntegerCache.low && i <= java.lang.Integer.IntegerCache.high)
            return java.lang.Integer.IntegerCache.cache[i + (-java.lang.Integer.IntegerCache.low)];
        return new java.lang.Integer(i);
    }

    //保存Integer类中的真实基本数据类型的值
    private final int value;

    //参数为int类型的构造函数
    public Integer(int value) {
        this.value = value;
    }

    //参数为String类型(其中包含的数字必须是十进制的)构造函数
    public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10);
    }

    //将int类型的值强转为byte类型
    public byte byteValue() {
        return (byte) value;
    }

    //将int类型的值强转为short类型
    public short shortValue() {
        return (short) value;
    }

    //输出Integer类对应的基本数据类型int值(Integer类中有个int value专门保存其基本类型的值)
    public int intValue() {
        return value;
    }

    //将int类型的值强转为long类型
    public long longValue() {
        return (long) value;
    }

    //将int类型的值强转为float类型
    public float floatValue() {
        return (float) value;
    }

    //将int类型的值强转为double类型
    public double doubleValue() {
        return (double) value;
    }

    //输出Integer类中存放基本数据类型真实值的value变量。
    public String toString() {
        return toString(value);
    }

    //返回int类型的值
    @Override
    public int hashCode() {
        return Integer.hashCode(value);
    }

    //返回int类型的值(自己的静泰方法)
    public static int hashCode(int value) {
        return value;
    }

    public boolean equals(Object obj) {
        //先比较是不是Integer类型，不是,则直接返回false，否则再比较值,
        if (obj instanceof java.lang.Integer) {
            return value == ((java.lang.Integer) obj).intValue();
        }
        return false;
    }

    /**
     * 返回系统常量的int值,类似System.getProperty(str);
     * @param nm   系统变量名(类似于key)
     * @return
     */
    public static Integer getInteger(String nm) {
        return getInteger(nm, null);
    }

    /**
     *
     * @param nm   系统常量名(也即是key)
     * @param val  若为该名字的系统常量的值为null，则返回该值的Integer对象
     * @return
     */
    public static Integer getInteger(String nm, int val) {
        Integer result = getInteger(nm, null);
        return (result == null) ? Integer.valueOf(val) : result;
    }

    /**
     *
     * @param nm
     * @param val
     * @return
     */
    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) {
            }
        }
        //该系统变量名对应的值为null,则返回默认值
        return val;
    }

    //作用：解码字符串转成Integer型对象
    public static Integer decode(String nm) throws NumberFormatException {
        //十进制
        int radix = 10;
        //当前判断完的字符数
        int index = 0;
        //非负标志
        boolean negative = false;
        //返回结果
        java.lang.Integer result;

        //字符串长度为0，则抛出数字转化异常
        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
        //然后剩下的字符串以0x或0X开头，表示十六进制
        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) {  //若以0开头，且字符串长度大于当前判断字符数+1,,则为8进制
            index++;
            radix = 8;
        }

        //再存在"-"/"+"这两字符，则抛出数字转化异常
        if (nm.startsWith("-", index) || nm.startsWith("+", index))
            throw new NumberFormatException("Sign character in wrong position");

        try {
            //将剩下的字符串从某进制转为十进制的数的包装类对象
            result = java.lang.Integer.valueOf(nm.substring(index), radix);
            //若是负数,取反包装类Integer中的value的值,再进行获取该基本数据类型的包装对象实例
            result = negative ? java.lang.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.
            //使用int类型参数转化出现异常，转而使用String类型参数进行转化
            String constant = negative ? ("-" + nm.substring(index))
                    : nm.substring(index);
            //转化字符串成对应的包装类的实例对象
            result = java.lang.Integer.valueOf(constant, radix);
        }
        return result;
    }

    /**
     * 比较两个包装类(Integer)对象中保存基本数据类型值的value是否相等
     * 小于    返回-1
     * 等于    返回0
     * 大于    返回1
     */
    public int compareTo(java.lang.Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }

    /**
     *  比较两个int类型的数据
     *  小于  返回-1
     *  等于  返回0
     *  大于  返回1
     */
    public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

    //将两个整数转换为无符号整数后比较大小
    public static int compareUnsigned(int x, int y) {
        return compare(x + MIN_VALUE, y + MIN_VALUE);
    }

    //将int型数据转成无符号long类型数
    public static long toUnsignedLong(int x) {
        return ((long) x) & 0xffffffffL;
    }

    /**
     *求无符号数的商
     * @param dividend  除数
     * @param divisor   被除数
     * @return
     */
    public static int divideUnsigned(int dividend, int divisor) {
        //为了避免复杂的代码，将int型的除数和被除数转为对应的无符号的Long类型并得到商
        return (int) (toUnsignedLong(dividend) / toUnsignedLong(divisor));
    }

    /**
     * 求无符号数的余数
     * @param dividend   除数
     * @param divisor    被除数
     * @return
     */
    public static int remainderUnsigned(int dividend, int divisor) {
        //为了避免复杂的代码，将int型的除数和被除数转为对应的无符号的Long类型并进行求余
        return (int) (toUnsignedLong(dividend) % toUnsignedLong(divisor));
    }

    //静态常量SIZE用来表四二进制补码形式的int值的比特数，值为32
    @Native
    public static final int SIZE = 32;

    //静态常量BYTES表示二进制补码形式的int值得字节数
    //Byte.SIZE=8   也就是8位等于一字节
    //BYTES=4   也就是4字节
    public static final int BYTES = SIZE / Byte.SIZE;

    //返回在二进制情况下，i的最高位为1，其他全为0的值。
    //将31位都置为1,然后将该值减去该值右移一位的值
    public static int highestOneBit(int i) {
        //右移一位或上原值
        i |= (i >> 1);
        i |= (i >> 2);
        i |= (i >> 4);
        i |= (i >> 8);
        i |= (i >> 16);
        //i值减去i右移一位的值
        return i - (i >>> 1);
    }

    //获取最低位为1，其他位都为0的值
    //具体操作：①先取负数(对正数的i取反码然后加1)，得到的结果和i进行与操作。
    public static int lowestOneBit(int i) {
        // HD, Section 2-1
        return i & -i;
    }

    //返回i的二进制从头开始有多少个0
    public static int numberOfLeadingZeros(int i) {
        // HD, Figure 5-6
        //i为0，则有32个0
        if (i == 0)
            return 32;
        int n = 1;
        //使用二分查找(也就是折半查找)思想，看右移16、24、28、30、31位的结果是否为0
        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;
    }

    // 返回i的二进制从尾开始有多少个0
    //基于二分查找
    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);
    }

    //计算二进制数中1的个数
    public static int bitCount(int i) {
        //每两位一组统计看有多少个1
        //0x55555555也就是01010101010101010101010101010101
        i = i - ((i >>> 1) & 0x55555555);
        //每四位一组统计看有多少个1
        //0x33333333也就是110011001100110011001100110011
        i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
        //每八位的1的个数
        //0x0f0f0f0f也就是00001111000011110000111100001111
        i = (i + (i >>> 4)) & 0x0f0f0f0f;
        //每16位
        i = i + (i >>> 8);
        //每32位
        i = i + (i >>> 16);
        //最终与0x3f进行与运算，得到的结果，就是1的个数
        return i & 0x3f;
    }

    //返回根据指定的位数循环左移指定的 int 值的二进制补码表示形式而得到的值。
    public static int rotateLeft(int i, int distance) {
        return (i << distance) | (i >>> -distance);
    }

    //返回根据指定的位数循环右移指定的 int 值的二进制补码表示形式而得到的值
    public static int rotateRight(int i, int distance) {
        return (i >>> distance) | (i << -distance);
    }

    //对i进行反转,反转也就是第1位和第32位对调，第2位和第31位对调等
    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;
        //32位中的中间16对调,最高八位和最低八位对调
        i = (i << 24) | ((i & 0xff00) << 8) |
                ((i >>> 8) & 0xff00) | (i >>> 24);
        return i;
    }

    // 返回指定 int 值的符号函数
    public static int signum(int i) {
        /**
         * 指定值i,为负数   返回-1
         *         为零     返回0
         *         为正数   返回1
         */
        //也就是返回最高位
        return (i >> 31) | (-i >>> 31);
}

    //按位进行反转
    public static int reverseBytes(int i) {
        return ((i >>> 24)) |  //第1字节
                ((i >> 8) & 0xFF00) |  //第二字节
                ((i << 8) & 0xFF0000) |  //第三字节
                ((i << 24));           //第四字节
    }

    /**
     * 加法
     * @param a    加数1
     * @param b    加数2
     * @return     和
     */
    public static int sum(int a, int b) {
        return a + b;
    }

    /**
     * 最大值
     * @param a    参数1
     * @param b    参数2
     * @return     两个参数中大的那个
     */
    public static int max(int a, int b) {
        return Math.max(a, b);
    }

    /**
     * 最小值
     * @param a    参数1
     * @param b    参数2
     * @return     两个参数中小的那个
     */
    public static int min(int a, int b) {
        return Math.min(a, b);
    }

    @Native
    //序列号
    private static final long serialVersionUID = 1360826667806852920L;
}

}