Integer源码解析

类定义

Java的Integer类主要的作用就是对基本类型int进行封装，提供了一些处理int类型的方法，比如int到String类型的转换方法或String类型到int类型的转换方法，当然也包含与其他类型之间的转换方法。除此之外还有一些位相关的操作

1	public final class Integer extends Number implements Comparable<Integer>

Integer被final修饰的,不可以被继承(由于被final修饰)
继承于Number类(该类继承了Serializable序列化接口),需要重写各种xxxValue方法，xxxValue方法就是转换成对应的类型。Number类是java.lang包下的一个抽象类,提供了将包装类型拆箱成基本类型的方法，所有基本类型的包装类型都继承了该抽象类
Integer实现了比较接口(需要重写compareTo方法)。自动装箱也就是调用了Integer类的一个静态方法valueOf方法(该方法返回Integer对象)

主要变量

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

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

//常量TYPE保存了当前包装类的对应的基本数据类型的Class实例,getPrimitiveClass----native方法
@SuppressWarnings("unchecked")
public static final Class<Integer> TYPE = (Class<Integer>) 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'
};

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

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

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

//静态常量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;

内部类

使用亨元模式，来减少对象的创建

//代码执行优先级：静态代码块(一个类)>代码块>构造函数
//内部类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() {
    }
}

构造方法

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

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

主要方法

toString

/**
 * 静态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);
}

/**
 * 静态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;
    }
}

hashcode

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

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

equals

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

填充字符数组

/**
 *填充字符数组
 * @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;
}

int类型对应字符串长度

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

parseInt(字符串转int)

/**
 *
 * @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);
}

自动装箱valueOf(int转Integer)

//将某进制的字符串转为Integer类型的数字
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));
}

//该方法直接获得在[low,high]范围内的IntegerCache缓存的Integer对象，不在该范围则重新实例化Integer对象[-128, 127]
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);
}

自动拆箱

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

getInteger

 /**
 * 返回系统常量的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;
}

decode

//作用：解码字符串转成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;
}

比较compare

/**
 * 比较两个包装类(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));
}

/**
 * 加法
 * @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);
}

位运算

//返回在二进制情况下，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));           //第四字节
}