JDK源码解析之 java.lang.Integer

栗筝i

发布于 2022-12-01 20:07:58

1640

发布于 2022-12-01 20:07:58

teger 基本数据类型int 的包装类 Integer 类型的对象包含一个 int 类型的字段

一、类定义

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

类被声明为final的,表示不能被继承;
继承了Number抽象类,可以用于数字类型的一系列转换;
实现了Comparable接口,强行对实现它的每个类的对象进行整体排序

二、成员变量

//保持 int类型的最大值的常量可取的值为 231－1。    
@Native public static final int   MIN_VALUE = 0x80000000;

//保持 int类型的最小值的常量可取的值为－231。   
@Native public static final int   MAX_VALUE = 0x7fffffff;

//表示基本类型 int 的Class 实例。    
    @SuppressWarnings("unchecked")
    public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

//以二进制补码形式表示 int 值的位数。
@Native public static final int SIZE = 32;
public static final int BYTES = SIZE / Byte.SIZE;

三、构造器

//    构造一个新分配的 Integer 对象，它表示指定的 int 值。
public Integer(int value) {
        this.value = value;
    }

//    构造一个新分配的Integer 对象，它表示 String 参数所指示的 int 值。
public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10);
    }

四、常用方法

1、parseInt(String s, int radix)

Integer(String s)引用的静态方法，进制转换的公式：a * radix^0 + b * radix^1 + c * radix^2 + … + xx * radix^(n-1)

public static int parseInt(String s, int radix) throws NumberFormatException{
    //如果转换的字符串如果为null，直接抛出空指针异常
    if (s == null) {
        throw new NumberFormatException("null");
    }
    //如果转换的radix(默认是10)<2 则抛出数字格式异常，因为进制最小是 2 进制
    if (radix < Character.MIN_RADIX) {
        throw new NumberFormatException("radix " + radix +
                                        " less than Character.MIN_RADIX");
    }
    //如果转换的radix(默认是10)>36 则抛出数字格式异常，因为0到9一共10位，a到z一共26位，所以一共36位
    //也就是最高只能有36进制数
    if (radix > Character.MAX_RADIX) {
        throw new NumberFormatException("radix " + radix +
                                        " greater than Character.MAX_RADIX");
    }
    int result = 0;
    boolean negative = false;
    int i = 0, len = s.length();//len是待转换字符串的长度
    int limit = -Integer.MAX_VALUE;//limit = -2147483647
    int multmin;
    int digit;
    //如果待转换字符串长度大于 0
    if (len > 0) {
        char firstChar = s.charAt(0);//获取待转换字符串的第一个字符
        //这里主要用来判断第一个字符是"+"或者"-"，因为这两个字符的 ASCII码都小于字符'0'
        if (firstChar < '0') {
            if (firstChar == '-') {//如果第一个字符是'-'
                negative = true;
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+')//如果第一个字符是不是 '+'，直接抛出异常
                throw NumberFormatException.forInputString(s);

            if (len == 1) //待转换字符长度是1，不能是单独的"+"或者"-"，否则抛出异常
                throw NumberFormatException.forInputString(s);
            i++;
        }
        multmin = limit / radix;
        //通过不断循环，将字符串除掉第一个字符之后，根据进制不断相乘在相加得到一个正整数
        //比如 parseInt("2abc",16) = 2*16的3次方+10*16的2次方+11*16+12*1
        //parseInt("123",10) = 1*10的2次方+2*10+3*1
        while (i < len) {
            digit = Character.digit(s.charAt(i++),radix);
            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 {//如果待转换字符串长度小于等于0，直接抛出异常
        throw NumberFormatException.forInputString(s);
    }
    //根据第一个字符得到的正负号，在结果前面加上符号
    return negative ? result : -result;
}

2、toString() toString(int i) toString(int i, int radix)

public String toString() {
    return toString(value);
}

public static String toString(int i) {
    if (i == Integer.MIN_VALUE)
        return "-2147483648";
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    char[] buf = new char[size];
    getChars(i, size, buf);
    return new String(buf, true);
}

  */
    public static String toString(int i, int radix) {
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;

        /* Use the faster version */
        if (radix == 10) {
            return toString(i);
        }

        char buf[] = new char[33];
        boolean negative = (i < 0);
        int charPos = 32;

        if (!negative) {
            i = -i;
        }

        while (i <= -radix) {
            buf[charPos--] = digits[-(i % radix)];
            i = i / radix;
        }
        buf[charPos] = digits[-i];

        if (negative) {
            buf[--charPos] = '-';
        }

        return new String(buf, charPos, (33 - charPos));
    }

toString(int) 方法内部调用了 stringSize() 和 getChars() 方法，stringSize() 它是用来计算参数 i 的位数也就是转成字符串之后的字符串的长度，内部结合一个已经初始化好的int类型的数组sizeTable来完成这个计算。

3、stringSize(int x)

final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                      99999999, 999999999, Integer.MAX_VALUE };

    // Requires positive x
    static int stringSize(int x) {
        for (int i=0; ; i++)
            if (x <= sizeTable[i])
                return i+1;
    }

实现的形式很巧妙。注意负数包含符号位，所以对于负数的位数是 stringSize(-i) + 1。

4、getChars(int i, int index, char[] buf)

static void getChars(int i, int index, char[] buf) {
        int q, r;
        int charPos = index;
        char sign = 0;

        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 = q;
            buf [--charPos] = DigitOnes[r];
            buf [--charPos] = DigitTens[r];
        }

        // Fall thru to fast mode for smaller numbers
        // assert(i <= 65536, i);
        for (;;) {
            q = (i * 52429) >>> (16+3);
            r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...
            buf [--charPos] = digits [r];
            i = q;
            if (i == 0) break;
        }
        if (sign != 0) {
            buf [--charPos] = sign;
        }
    }

5、equals(Object obj)

这个方法很简单，先通过 instanceof关键字判断两个比较对象的关系，然后将对象强转为 Integer，在通过自动拆箱，转换成两个基本数据类 int，然后通过 == 比较。

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

6、hashCode() 方法

public int hashCode() {
         return value;
    }

7、compareTo(Integer anotherInteger) 和 compare(int x, int y)

compareTo 方法内部直接调用 compare 方法：

public int compareTo(Integer anotherInteger) {
         return compare(this.value, anotherInteger.value);
     }
public static int compare(int x, int y) {
         return (x < y) ? -1 : ((x == y) ? 0 : 1);
     }

如果 x < y 返回 -1，如果 x == y 返回 0，如果 x > y 返回 1

8、内部类IntegerCache

IntegerCache为Integer类的缓存类，默认缓存了-128~127的Integer值，如遇到[-128,127]范围的值需要转换为Integer时会直接从IntegerCache中获取

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        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, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

五、拓展

1、一道面试题

        Integer a1 = 100;
        Integer a2 = 100;
        Integer a3 = 1000;
        Integer a4 = 1000;
        System.out.println(a1==a2);
        System.out.println(a3==a4);

输出答案，分别是true和false，我们知道Integer是int的包装类，所以a1,b1.c1,d1都是引用变量，比较的是地址，但为什么在等于100和1000的时候结果不一样呢？

通过查看源码知道，Integer在对-128-127之间的数进行了缓存，就是说之前我创建了a1为100，而当创建a2的时候自动指向a1的地址，所以就不难解释为什么a1==a2为true了。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2020-08-20，如有侵权请联系 cloudcommunity@tencent.com 删除

缓存

java

编程算法

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

缓存

java

编程算法

登录后参与评论

0 条评论

热度