算法与数据结构面试题(23)-将字符串转化为整形

题目


输入一个表示整数的字符串,把该字符串转换成整数并输出。 例如输入字符串"345",则输出整数 345。

个人理解


这个面试题不太 涉及算法和数据结构,主要考察你的编程习惯,有没有意识去做一些验证,对输入的校验。小问题验证大方面。乘机我们来看看java api中对这个问题的处理


代码


public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }

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.
         */

        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;
        boolean negative = false;
        int i = 0, len = s.length();
        int limit = -Integer.MAX_VALUE;
        int multmin;
        int digit;

        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);
        }
        return negative ? result : -result;
    }

先了解下面的知识,对理解上面的代码有好处。


在Java中>、>>、>>>三者的区别
在java中:

>表示大于,如:if(a>b)...结果是boolean类型

>>表示右移,如:int i=15; i>>2的结果是3,移出的部分将被抛弃。

转为二进制的形式可能更好理解,0000 1111(15)右移2位的结果是0000 0011(3),0001 1010(18)右移3位的结果是0000 0011(3)。

j>>>i 与 j/(int)(Math.pow(2,i))的结果相同,其中i和j是整形。


我们一步一步的debug, 来看看处理代码


1.进入


public static void main(String[] args){
        //10进制
        Integer.parseInt("235",10);

    }

上面是入口函数。


算法与数据结构面试题(23)-将字符串转化为整形_第1张图片


传入的字符串为"235"。进入方法体后,第一步是判断是否为null。如果为空,抛出异常。然后是判断基数是否在可允许范围内[2-32],我们传入的是10。在可允许内


2.初始化操作


算法与数据结构面试题(23)-将字符串转化为整形_第2张图片


result:我们需要的结果

negative:是否为负数。默认为false

i:游标,指向字符串当前的索引,遍历字符串中字符。

len:字符串大小

limit:整形的最大值的负值。比整形的最小值-2147483648大1.

multmin:

digit:保存字符经过转化后的整形值


3.判断字符串第一个字符是否是符号位(+,-)


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++;
            }

如果第一个字符为'-',将negative的值设置为true,将limit设置为整形最小值:Integer.MIN_VALUE。

如果第一个字符不为‘-’,然后再附加判断一下是否为加号,如果不是加号,抛出异常

再然后判断一下字符串的大小是否为1,如果为1,不符合要求,因为只有符号位肯定是不复制整数的定义的。

最后字符串遍历的游标自增1。表示遍历要从第二个字符开始,因为第一个字符我们已经判断是符号位。


4.遍历字符串


算法与数据结构面试题(23)-将字符串转化为整形_第3张图片


首先我们将multmin的值赋上值,赋上值有啥作用?,它为啥要除以基准值。暂时还不清楚。先放着吧。


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

首先了解第一个语句块


digit = Character.digit(s.charAt(i++),radix);

算法与数据结构面试题(23)-将字符串转化为整形_第4张图片


可以看见字符'2'的ascii码为50,我们对照一下的确是50。


算法与数据结构面试题(23)-将字符串转化为整形_第5张图片


上面的方法中,首先将字符转换成ascii码,然后再调用覆盖函数digit。


算法与数据结构面试题(23)-将字符串转化为整形_第6张图片


这个时候会发现传进来的是50,也就是‘2’的ascii码值。进入该函数后,首先通过CharacterData.of方法来得到该字符属于哪个编码集范围内。


static final CharacterData of(int ch) {
        if (ch >>> 8 == 0) {     // fast-path
            return CharacterDataLatin1.instance;
        } else {
            switch(ch >>> 16) {  //plane 00-16
            case(0):
                return CharacterData00.instance;
            case(1):
                return CharacterData01.instance;
            case(2):
                return CharacterData02.instance;
            case(14):
                return CharacterData0E.instance;
            case(15):   // Private Use
            case(16):   // Private Use
                return CharacterDataPrivateUse.instance;
            default:
                return CharacterDataUndefined.instance;
            }
        }
    }

首先ch>>>8位运算。意思是ch/2的8次方法。主要是判断是否可以用拉丁字符范围内的值表示。很显然我们可以用拉丁字符编码集中字符范围来表示。所以方法返回。


进入CharacterDataLatin1类的digit方法


int digit(int ch, int radix) {
        int value = -1;
        if (radix >= Character.MIN_RADIX && radix <= Character.MAX_RADIX) {
            int val = getProperties(ch);
            int kind = val & 0x1F;
            if (kind == Character.DECIMAL_DIGIT_NUMBER) {
                value = ch + ((val & 0x3E0) >> 5) & 0x1F;
            }
            else if ((val & 0xC00) == 0x00000C00) {
                // Java supradecimal digit
                value = (ch + ((val & 0x3E0) >> 5) & 0x1F) + 10;
            }
        }
        return (value < radix) ? value : -1;
    }

首先判断基准值是不是符合要求,这个已经比对过了,无需再说了。然后进入getProperties方法。


 int getProperties(int ch) {
        char offset = (char)ch;
        int props = A[offset];
        return props;
    }

返回了一个很大的数,为unicode值;暂且理解为unicode码转化为10进制后的数,然后与16进制数0x1F做 位与运算。


算法与数据结构面试题(23)-将字符串转化为整形_第7张图片


为何要做位与运算,先来看看位于运算是什么?


& 是按二进制的按位与,即 1 & 1 = 1   1 & 0 = 0   3 & 1 → 11(二进制) & 1 = 1

上面的0x1F表示的是二进制数为:00011111。如果按照上面的运算法则,那么只有后5位为1的位才能被保留下来。


10进制数402667017转化为二进制数为


11000000000000011011000001001

那么后5位为01001&11111 = 01001;所以我们知道其实就是取后5位的数二进制码,其他位置全部改为0。得到的10进制数就是9。


if (kind == Character.DECIMAL_DIGIT_NUMBER) 

根据这句代码我们知道,和0x1F位于是要计算出其所处的类别。9代表的是Unicode 规范中的常规类别“Nd”。然后再做如下的位运算


value = ch + ((val & 0x3E0) >> 5) & 0x1F;

0x3E0 = 10 1111 0000 &10 0000 1001 = 10 0000 0000  然后向右位移5位得到10 000由于优先级+大于&。所以先进行相加运算50+16 = 66 (1000010)

1000010&11111 = 10 =,10进制就为2;所以最后的value = 2;


所以方法返回到Integer.parseInt中,得到digit = 2;


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

然后是2个if判断。很容易理解:不能为负数,因为此时计算的位数没有符号可言。

后面一个判断result

你可能感兴趣的:(算法与数据结构,LeetCode)