java.lang.Integer源码精读(一)

Wesley13
• 阅读 536

分享不易,喜欢请点赞支持,谢谢

JDK源码精读汇总帖

类声明

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

public abstract class Number implements java.io.Serializable {}
  • 抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的超类。
  • Number 的子类必须提供将表示的数值转换为 byte、double、float、int、long 和 short 的方法。
  • Integer中对应的方法就是类型转换,将int转换成byte、double、float、long 和 short 类型。

compareTo

​ 实现了Comparable,看看对应的方法,很好理解

public int compareTo(Integer anotherInteger) {
    return compare(this.value, anotherInteger.value);
}

/**
 * jdk1.7之后单独抽取出来的static方法,可以作为工具方法用于比较两个整数
 */
public static int compare(int x, int y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

toString(int)

看看非常常用的toString方法

public static String toString(int i) {
    // 如果是Integer的最小值,直接返回字符串"-2147483648"
    if (i == Integer.MIN_VALUE)
        return "-2147483648";
    // 计算形参i的位数,负数的话,size要比数字本身多1,用来存储负号(-)
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    // 构造一个用于存储数字的字符数组
    char[] buf = new char[size];
    // 填充字符数组
    getChars(i, size, buf);
    return new String(buf, true);
}

先看看stringSize方法,这个方法返回的是形参i的位数

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

// 要求形参x为正数
static int stringSize(int x) {
    // 一个个和sizeTable比较,到第i个数代表x由(i+1)个数字组成
    for (int i=0; ; i++)
        if (x <= sizeTable[i])
            return i+1;
}

再看看getChars方法,这个方法就是将组成形成i的每一个数字,填充到buf数组里。在看getChars这个方法之前可以先思考一下,怎么样获取形参i的每个位置上的数字呢?其实就是循环:①每次除以10求余(%),得到的就是个位上的数字;②然后再将形参i除以10,整数相除,尾数(即前面的余数)就会被丢弃;③重复①②直到形参i变成0。如12,第一次循环:除以10求余得到2,就是个位数上的数字是2,然后除以10,得到1,个位数上的2就被丢弃了,第二次循环:除10求余得到1,然后除以10得到0,于是分别得到了2和1,循环结束了。用代码来看的话就是:

while (true) {
    r = i % 10;
    i /= 10;
    // 伪代码↓
    // 第n次循环,将r加入到buf的倒数第n位上
    if (i == 0) break;

以上只考虑了正数的情况,对于负数的情况,只要再循环结束后,在buf的第0个位置加上一个'-'即可,完整代码如下:

static void myGetChars(int i, int index, char[] buf) {
    int charPos = index;// 用来记录buf每次可插入的尾部
    char sign = 0;// 是否为负数的标记
    if (i < 0) {
        sign = '-';
        i = -i;// 当成正数处理
    }        
    while (true) {
        int r = i % 10;
        i /= 10;
        buf [--charPos] = digits [r];// 将数字r转成字符'r',然后添加到buf的可插入尾部
        if (i == 0) break;
    }
    if (sign != 0) {
        buf [--charPos] = sign;
    }
}

看样子好像实现了getChars的功能,但是jdk里面是不是这么做的呢?答案是:no!看看源码:

static void getChars(int i, int index, char[] buf) {
    int q, r;// r为余数,就是每次被插入到buf的数
    int charPos = index;// buf可插入尾部
    char sign = 0;

    if (i < 0) {
        sign = '-';
        i = -i;
    }

    // i >= 65536时
    // 每次迭代向buf插入2个数字,即i的最后两位,目的应该是加快迭代速度
    while (i >= 65536) {
        q = i / 100;
        // really: r = i - (q * 100);
        // 本质就是r = i - (q * 100)
        // q << 6 = 2^6 = 64
        // q << 5 = 2^5 = 32
        // q << 2 = 2^2 = 4
        // i - q * 100 得到的r就是i的末尾2位数,本质是i%100,应该是乘法运算速度大于除法,大于求余,但是减法的速度应该也不算快
        r = i - ((q << 6) + (q << 5) + (q << 2));
        i = q;
        // 插入r的个位数
        buf [--charPos] = DigitOnes[r];
        // 插入r的十位数
        buf [--charPos] = DigitTens[r];
    }

    // Fall thru to fast mode for smaller numbers
    // assert(i <= 65536, i);
    for (;;) {
        // 这里本质就是i/10,
        q = (i * 52429) >>> (16+3);
        r = i - ((q << 3) + (q << 1));  // 本质就是 r = i-(q*10)
        buf [--charPos] = digits [r];// 将数字r转成字符'r',然后添加到buf的可插入尾部
        i = q;
        if (i == 0) break;
    }
    if (sign != 0) {// 如果是负数,再插入'-'
        buf [--charPos] = sign;
    }
}

这里有几个比较有意思的地方:

  • 首先是分段来获取字符,分成>=65535和<65535两段,大于等于65535的部分,每次迭代获取两个字符,这里有个疑问的地方是,为什么不分成>=10和<10两部分呢,难道是后面这一小段代码的执行速度比较快?
  • 其次是<65535这部分,对于q = (i * 52429) >>> (16+3);,这个代码等价于q = i / 10;,应该是ALU执行乘法和移位运算的速度快过除法的运算速度。但是为什么是52429和2^19 (2的19次方,无符号右移19位相当于除以2的19次方),这是出于精度同时不会溢出这两方面考虑的。首先说精度方面,(double)52429/524288=0.100000381469,这个精度完全可以保证求出i的十分之一,比如选了一个精度不够的,求出值为0.103,那么如果i是999,999*0.103=102,并不是999的十分之一99;另外一方面,65536=2^16,52429<65536,所以i * 52429 < 2^32,不会溢出,至于i * 52429 会导致结果变成负数的问题,这只是中间结果,无符号右移19位之后,高位全部补0,结果q还是正数。
    以上可以看出,jdk还是蛮严谨的,为了效率也是拼了。
  • 但实际测试的结果感觉运算效率并没有很大提高,可能是以前的ALU没有现在的先进。

toString(int, int)

​ 接下来看看toString(int i, int radix),这个方法主要是将形参i转成radix进制的数

public static String toString(int i, int radix) {
    // 如果小于2进制或大于36进制,当成10进制处理
    if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
        radix = 10;

    /* Use the faster version */
    // 10进制数,直接使用更快的版本
    if (radix == 10) {
        return toString(i);
    }

    // Integer最多占用33位,数字32位,符号1位
    char buf[] = new char[33];
    boolean negative = (i < 0);// 判断是否为负数,后面i被当成负数来统一处理
    int charPos = 32;// buf最末尾的索引,从32开始

    // 如果i是正数,取反,当成负数处理
    if (!negative) {
        i = -i;
    }

    // i%radix的余数的绝对值放到buf当前尾部(charPos)位置
    while (i <= -radix) {
        buf[charPos--] = digits[-(i % radix)];
        i = i / radix;
    }
    buf[charPos] = digits[-i];

    // 如果i是负数,加上'-'
    if (negative) {
        buf[--charPos] = '-';
    }
    // 返回字符串,从buf的charPos位置开始截取,长度33-charPos,正好是最后一个位置,索引下标为32
    return new String(buf, charPos, (33 - charPos));
}

toString()

​ 无参的toString就没什么难度了,就是把Integer封装的value转成字符串

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

toHexString(int)

​ 接下来看看几个无符号进制的转换

public static String toHexString(int i) {
    return toUnsignedString(i, 4);
}
public static String toOctalString(int i) {
    return toUnsignedString(i, 3);
}
public static String toBinaryString(int i) {
    return toUnsignedString(i, 1);
}
/**
 * 本质上就是理解这个方法
 * 因为是无符号,所以所有数字其实都可以想象成二进制的情况,如17则是0000 0000 0000 0000 0000 0001 0001 0001,-17则是1111 1111 1111 1111 1111 1111 1110 1111
 */
private static String toUnsignedString(int i, int shift) {
    // 无符号数,只需存32位即可
    char[] buf = new char[32];
    // 可插入的尾部位置
    int charPos = 32;
    // 进制
    int radix = 1 << shift;
    // 类似掩码的作用,二进制是对应的是0001,八进制对应0111,十六进制对应1111
    int mask = radix - 1;
    do {
        // 关键理解i & mask,整个过程就像手工转换进制一样,先得到二进制,然后每几位一组转换,如0001 0001转成8进制,每3位一组:00 010 001,然后得到0 2 1,所以17的8进制表示就是21,i & mask的过程就像分组,每次迭代将mask对应的位数得到,再利用digits转换成对应的字符
        buf[--charPos] = digits[i & mask];
        i >>>= shift;
    } while (i != 0);

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

演示一下i & mask的过程:

  • i=17,mask=7,则相当于0001 0001 & 0111 得到001,digit[1]
    =1,第二次迭代i=000 010,000 010 & 0111得到010,digit[2]=2,迭代结束,buf=21。
  • i=17,mask-15,则相当于0001 0001 & 1111 得到0001,digit[1]
    =1,第二次迭代i=0001,0001 & 1111得到0001,digit[1]=1,迭代结束,buf=11。

parseInt(String, int)

​ 接着看parseInt方法,进制转换的公式:a * radix^0 + b * radix^1 + c * radix^2 + ... + xx * radix^(n-1)

/**
 * 整个过程的关键点都在判断下一次迭代会不会导致溢出
 * 
 */
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.
     */

    // 下面都是判断s不能为空,进制必须在[2, 36],可以看到jdk的源码处理也有问题,之前进制转换的,不在[2, 36]之间就当成10进制处理,现在是抛异常,规则不一样
    if (s == null) {
        throw new NumberFormatException("null");
    }

    if (radix < Character.MIN_RADIX) {
        throw new NumberFormatException("radix " + radix +
                                        " less than Character.MIN_RADIX");
    }

    if (radix > Character.MAX_RADIX) {
        throw new NumberFormatException("radix " + radix +
                                        " greater than Character.MAX_RADIX");
    }

    // 当前的转换结果
    int result = 0;
    // 后面的处理都基于负数处理,一方面是统一规则,另外Integer.MIN_VALUE的绝对值比较大
    boolean negative = false;
    int i = 0, len = s.length();
    // 后面两个参数限制溢出的作用
    int limit = -Integer.MAX_VALUE;
    // 界定溢出,具体看下面的注释
    int multmin;
    // 通过Character#digit转换过来的数值
    int digit;

    if (len > 0) {
        // 处理第一个字符
        char firstChar = s.charAt(0);
        if (firstChar < '0') { // Possible leading "+" or "-"
            if (firstChar == '-') {
                negative = true;
                // 如果是负数,溢出标志变成Integer.MIN_VALUE
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+')
                throw NumberFormatException.forInputString(s);

            if (len == 1) // Cannot have lone "+" or "-"
                throw NumberFormatException.forInputString(s);
            i++;
        }
        // 界定是否溢出的标志,假设10进制最大是211,则multmin = 211 / 10 = 21,假设现在result为30,那么下一次迭代result *= radix肯定会大于211,溢出了。
        multmin = limit / radix;
        while (i < len) {
            // Accumulating negatively avoids surprises near MAX_VALUE
            // 转换函数,具体在Character类了解
            digit = Character.digit(s.charAt(i++),radix);
            if (digit < 0) {
                throw NumberFormatException.forInputString(s);
            }
            // 因为是当成负数(limit是负数)处理,相当于正数的result > multmin
            if (result < multmin) {
                throw NumberFormatException.forInputString(s);
            }
            result *= radix;// 迭代,就是套公式a * radix^(n-1)的过程
            // 同样是判断溢出的过程,继续上面的分析,result现在是210,如果digit是2,则转换后的result = 212,也是溢出了。
            if (result < limit + digit) {
                throw NumberFormatException.forInputString(s);
            }
            result -= digit;// 公式里相加的过程,负数的话就是减
        }
    } else {
        throw NumberFormatException.forInputString(s);
    }
    return negative ? result : -result;
}
// 这个就是调用上面的方法
public static int parseInt(String s) throws NumberFormatException {
  return parseInt(s,10);
}

valueOf()

​ 接着看看valueOf方法,在看valueOf方法之前,需要先看看IntegerCache,顾名思义,这个是整数的缓存,默认情况下,IntegetCache会缓存[-128, 127]的所有实例,所以正常情况下,在这两个值范围内的对象都是相等的(==返回true),因为它们引用的是同一块内存上的对象,有点单例的意思,当然可以通过启动参数-XX:AutoBoxCacheMax=size来修改缓存的内容(size必须大于127,否则当成127)来让jvm缓存[-size-1, size]的对象。看看代码:

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) {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);// 如果配置的值比127小,缓存上界还是127
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            // 对象一个个缓存起来,用cache数组保存
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }

具体看看valueOf方法

// 调用的parseInt方法以及分析过
public static Integer valueOf(String s, int radix) throws NumberFormatException {
  return Integer.valueOf(parseInt(s,radix));
}
public static Integer valueOf(String s) throws NumberFormatException {
  return Integer.valueOf(parseInt(s, 10));
}
public static Integer valueOf(int i) {
  assert IntegerCache.high >= 127;// 防止IntegetCache函数上界不是127
  // 在[IntegetCache.low, Integer.high]直接的直接从缓存中返回
  if (i >= IntegerCache.low && i <= IntegerCache.high)
    return IntegerCache.cache[i + (-IntegerCache.low)];
  return new Integer(i);// 否则新建一个实例
}

分享不易,转载请注明出处

java.lang.Integer源码精读(一)
地址:https://www.jianshu.com/p/02c1d9092347

点赞
收藏
评论区
推荐文章
blmius blmius
3年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时,报错:原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等,这样可以更容易地在不同的环境中使用MySQL。全局s
Karen110 Karen110
3年前
一篇文章带你了解JavaScript日期
日期对象允许您使用日期(年、月、日、小时、分钟、秒和毫秒)。一、JavaScript的日期格式一个JavaScript日期可以写为一个字符串:ThuFeb02201909:59:51GMT0800(中国标准时间)或者是一个数字:1486000791164写数字的日期,指定的毫秒数自1970年1月1日00:00:00到现在。1\.显示日期使用
Easter79 Easter79
3年前
swap空间的增减方法
(1)增大swap空间去激活swap交换区:swapoff v /dev/vg00/lvswap扩展交换lv:lvextend L 10G /dev/vg00/lvswap重新生成swap交换区:mkswap /dev/vg00/lvswap激活新生成的交换区:swapon v /dev/vg00/lvswap
待兔 待兔
4个月前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
Jacquelyn38 Jacquelyn38
3年前
2020年前端实用代码段,为你的工作保驾护航
有空的时候,自己总结了几个代码段,在开发中也经常使用,谢谢。1、使用解构获取json数据let jsonData  id: 1,status: "OK",data: 'a', 'b';let  id, status, data: number   jsonData;console.log(id, status, number )
Wesley13 Wesley13
3年前
Java获得今日零时零分零秒的时间(Date型)
publicDatezeroTime()throwsParseException{    DatetimenewDate();    SimpleDateFormatsimpnewSimpleDateFormat("yyyyMMdd00:00:00");    SimpleDateFormatsimp2newS
Wesley13 Wesley13
3年前
mysql设置时区
mysql设置时区mysql\_query("SETtime\_zone'8:00'")ordie('时区设置失败,请联系管理员!');中国在东8区所以加8方法二:selectcount(user\_id)asdevice,CONVERT\_TZ(FROM\_UNIXTIME(reg\_time),'08:00','0
Wesley13 Wesley13
3年前
00:Java简单了解
浅谈Java之概述Java是SUN(StanfordUniversityNetwork),斯坦福大学网络公司)1995年推出的一门高级编程语言。Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟,已经成为Web应用程序的首选开发语言。Java是简单易学,完全面向对象,安全可靠,与平台无关的编程语言。
Stella981 Stella981
3年前
Docker 部署SpringBoot项目不香吗?
  公众号改版后文章乱序推荐,希望你可以点击上方“Java进阶架构师”,点击右上角,将我们设为★“星标”!这样才不会错过每日进阶架构文章呀。  !(http://dingyue.ws.126.net/2020/0920/b00fbfc7j00qgy5xy002kd200qo00hsg00it00cj.jpg)  2
Wesley13 Wesley13
3年前
MySQL部分从库上面因为大量的临时表tmp_table造成慢查询
背景描述Time:20190124T00:08:14.70572408:00User@Host:@Id:Schema:sentrymetaLast_errno:0Killed:0Query_time:0.315758Lock_
Python进阶者 Python进阶者
10个月前
Excel中这日期老是出来00:00:00,怎么用Pandas把这个去除
大家好,我是皮皮。一、前言前几天在Python白银交流群【上海新年人】问了一个Pandas数据筛选的问题。问题如下:这日期老是出来00:00:00,怎么把这个去除。二、实现过程后来【论草莓如何成为冻干莓】给了一个思路和代码如下:pd.toexcel之前把这