Integer源码解读(JDK8)

雨点打透心脏的1/2处 2022-05-14 07:18 329阅读 0赞

//八大基本数据类型：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<java.lang.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'
        };
    
        /**
         * 静态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;
    }
    
    }