文章
52
标签
19
分类
10
首页
档案
标签
分类
友链
关于
列表
目录
  1. 1. Integer源码解析
    1. 1.1. 类定义
    2. 1.2. 主要变量
    3. 1.3. 内部类
    4. 1.4. 构造方法
    5. 1.5. 主要方法
      1. 1.5.1. toString
      2. 1.5.2. hashcode
      3. 1.5.3. equals
      4. 1.5.4. 填充字符数组
      5. 1.5.5. int类型对应字符串长度
      6. 1.5.6. parseInt(字符串转int)
      7. 1.5.7. 自动装箱valueOf(int转Integer)
      8. 1.5.8. 自动拆箱
      9. 1.5.9. getInteger
      10. 1.5.10. decode
      11. 1.5.11. 比较compare
      12. 1.5.12. 数值运算
      13. 1.5.13. 位运算
Integer源码解析
|01-Java基础篇02-JDK源码篇
阅读量: 22

Integer源码解析

类定义

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

java
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对象)

主要变量

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
//最小值常量(十六进制补码形式表示):-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;

内部类

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

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//代码执行优先级：静态代码块(一个类)>代码块>构造函数
//内部类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() {
    }
}

构造方法

java
1
2
3
4
5
6
7
8
9
//参数为int类型的构造函数
public Integer(int value) {
    this.value = value;
}

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

主要方法

toString

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
/**
 * 静态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

java
1
2
3
4
5
6
7
8
9
10
//返回int类型的值
@Override
public int hashCode() {
    return Integer.hashCode(value);
}

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

equals

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

填充字符数组

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
 *填充字符数组
 * @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类型对应字符串长度

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

parseInt(字符串转int)

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
/**
 *
 * @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)

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//将某进制的字符串转为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);
}

自动拆箱

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//将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

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 /**
 * 返回系统常量的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

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
//作用：解码字符串转成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

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * 比较两个包装类(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);
}

数值运算

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
//将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);
}

位运算

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
//返回在二进制情况下，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));           //第四字节
}
文章作者: Eric Liang
文章链接: https://ericql.github.io/2019/11/12/01-Java%E5%9F%BA%E7%A1%80%E7%AF%87/02-JDK%E6%BA%90%E7%A0%81%E7%AF%87/Integer%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 Eric Liang！
JDK源码解析 Integer
打赏
  • 微信
  • 支付宝
相关推荐
Enum源码解析
ThreadLocal源码解析
ClassLoader源码解析
Long源码解析
String源码解析
BigDecimal源码解析
繁