java.lang.Integer#parseInt() 源码分

2020-03-27 本文已影响0人 mlya

Integer#parseInt() 是我们经常使用的一个函数, 是 String 类提供的一个静态工具方法, 其作用就是将字符串的数字转换为 int 类型.

一个更通用的 parseInt() 的方法拥有两个参数, 其函数签名定义如下:

public static int parseInt(String s, int radix) throws NumberFormatException {}

String s: 待解析的字符串
int radix: 进制 (如果不指定这个参数, 默认为 10 进制)

使用范围

这个方法可以合法使用的例子如下:

parseInt("0", 10) returns 0
parseInt("473", 10) returns 473
parseInt("+42", 10) returns 42
parseInt("-0", 10) returns 0
parseInt("-FF", 16) returns -255
parseInt("1100110", 2) returns 102
parseInt("2147483647", 10) returns 2147483647
parseInt("-2147483648", 10) returns -2147483648
parseInt("2147483648", 10) throws a NumberFormatException
parseInt("99", 8) throws a NumberFormatException
parseInt("Kona", 10) throws a NumberFormatException
parseInt("Kona", 27) returns 411787

需要注意的有以下几点:

可以包括正负数符号 +, -
对于每个进制的数, 只能包含这个进制所能包含的有效数字, 不然会抛出 NumberFormatException

源码分析

异常检测

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");
}

第一部分完成异常检测, 如果 s 为 null 或者 radix 不在有效范围内, 抛出异常.

有效的进制范围为 2~36, 最小为 2 进制, 最大为 36 进制 (因为有 26 个英文字母, 26 + 10 = 36)

变量定义

在解析过程中, 所使用的变量包括如下:

int result = 0; // 最后返回的解析结果
boolean negative = false; // 标记所解析的数是正数还是负数
int i = 0, len = s.length(); // 解析的下标和字符串总长度 (从左到右进行解析)
int limit = -Integer.MAX_VALUE; // 所能解析数的最大范围
int multmin; // 在解析最后一位数字之前的最大范围
int digit; // 所解析的每一位数字

解析思路说明

在解释上述变量的具体设定之前, 有必要先对解析的思路进行说明.

int 变量正数和负数的范围不一致

int 变量正数和负数的范围是不一致的, int 的范围是 $-2^{32}$ ~ $2^{32} - 1$ , 即 -2147483648 ~ 2147483647, 正数和负数的范围是不一致的.

我们在解析负数的时候, 是使用一个 int 值 result 和 boolean 值 negative 组合来完成最后数值的解析的.

如果我们要解析的数是 -2147483648, 那么, 在解析的过程中, 需要存储一个 2147483648 的值, 那么直接用 int 存储 2147483648, 会发生溢出.

因此这里的解决方案是, 使用负数来进行存储, 避免溢出.

解析代码

解析代码的主体如下:

if (len > 0) {
    char firstChar = s.charAt(0);
    if (firstChar < '0') { // Possible leading "+" or "-"
        if (firstChar == '-') {
            negative = true;
            limit = 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
        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 {
    throw NumberFormatException.forInputString(s);
}

上面就是解析代码的主体, 下面来一部分一部分进行分析.

正负符号的解析

第一部分为正负号的解析, 这部分逻辑简单, 其中有很多注释说明的很清楚了.

char firstChar = s.charAt(0); // 获取第一个字符
if (firstChar < '0') { // Possible leading "+" or "-"
    if (firstChar == '-') {
        negative = true;
        limit = Integer.MIN_VALUE; // 如果是负值的话, 重新指定限制范围
    } else if (firstChar != '+')
        throw NumberFormatException.forInputString(s);

    if (len == 1) // Cannot have lone "+" or "-"
        throw NumberFormatException.forInputString(s);
    i++;
}

数值的解析

这部分是数值解析的重点, 基本逻辑很简单, 但是其中有很多很多的坑, 一不留神就会写出有 bug 的代码, 我们细细分析一下.

我们上面已经说明了, 我们使用的是负数进行存储的, 以避免溢出.

multmin = limit / radix; // 指定 multmin 的值, 这个值的作用在下面说明
while (i < len) {
    // Accumulating negatively avoids surprises near MAX_VALUE
    digit = Character.digit(s.charAt(i++),radix); // 调用 Character.digit() 方法进行解析
    if (digit < 0) {
        throw NumberFormatException.forInputString(s);
    }
    if (result < multmin) { // 因为是负值存储, 所以小于说明越界了, 如果当前数值已经超过了 multmin, 那么说明在添加当前数值之前, 就已经越界了, 直接抛出异常. 提前判断一次的原因, 是因为防止下一步越界
        throw NumberFormatException.forInputString(s);
    }
    result *= radix; // 就是因为要进行这一步操作, 所以要在更新 result 值之前, 先比较 result 和 multmin, 如果已经越界了, 那么再进行这一步操作, 就会越界
    if (result < limit + digit) { // 判断增加了当前值之后, 会不会越界
        throw NumberFormatException.forInputString(s);
    }
    result -= digit; // 添加当前数值, 注意我们是使用负数存储的, 通过上面的代码, 保证到这一步一定不会发生溢出.
}

细节说明

multmin 的使用

为什么要多此一举的使用 multmin 呢?

在下面的代码中, multmin 的取值为:

multmin = limit / radix;

下面举例说明 multmin 的使用原因.

为去除最后一位数之后的最大范围, 例如, limit 取 -2147483648, radix 为 10 , multmin 的值为 -214748364, 为去除最后一位数之后的最大取值.

如果所解析的数为 2147483659, 超过了最大范围, 去除最后一位之后, result 的值为 -214748365, 这时, 如果再执行 result *= radix, 那么会得到 -2147483650, 就已经越界了, result 的值就不再正确了. 而提前比较了 multmin 值, 就能提前判断, 提前抛出异常.

比较 result < limit + digit

if (result < limit + digit) { // 判断增加了当前值之后, 会不会越界
    throw NumberFormatException.forInputString(s);
}

上述逻辑判断的是, result 加上当前数值之后, 会不会发生越界, 最朴素的思路是, result - digit 是不是小于 limit, 即写成 result - digit < limit.

这里有个坑就是, 如果写成上面的样子, 会发生溢出, 因为 result - digit 会产生溢出, 但是我们移项过去之后, result < limit + digit 就没有问题.

总结

看似解析数值非常简单, 但是里面的坑真的是非常多, 我们可以好好学一下这个代码, 避免很多数值溢出的坑, 对我们以后写代码也会有很好的学习作用.