leetcode-java字符串转整数(atoi)

字符串转整数(atoi)

题目描述：

leetcode 8.字符串转换整数(中等)
请你来实现一个 atoi 函数，使其能将字符串转换成整数。

首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。

当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。

该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。

注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0。

说明：

假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231,  231 − 1]。如果数值超过这个范围，请返回  INT_MAX (231 − 1) 或 INT_MIN (−231) 。

示例 1:

输入: "42"
输出: 42
示例 2:

输入: "   -42"
输出: -42
解释: 第一个非空白字符为 '-', 它是一个负号。
     我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。
示例 3:

输入: "4193 with words"
输出: 4193
解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。
示例 4:

输入: "words and 987"
输出: 0
解释: 第一个非空字符是 'w', 但它不是数字或正、负号。
     因此无法执行有效的转换。
示例 5:

输入: "-91283472332"
输出: -2147483648
解释: 数字 "-91283472332" 超过 32 位有符号整数范围。
     因此返回 INT_MIN (−231) 。

有符号整数范围 -2的31次方     --    2的31次方-1

数字的Ascii码值 0-9 <--> 48-57
大写字母的Ascii码值 A-Z <--> 65-90
小写字母的Ascii码值 a-z <--> 97-122
 - 减号字符的Ascii码值 45
 + 加号字符的Ascii码值 43

问题分析：

要考虑多种情况以及相关处理：
	字符串为空	-->	str.length() == 0
	首尾空格		--->	str.trim()函数 去除首尾空格
	紧接着判定字符串全为空格的情况 --> str.length() == 0
	判断合法首字母是不是数字字符以及加号，减号字符
	判定第一个合法字符是否为 - 号使用标志位记着
	将合法连续数字字符加入到 StringBuild类 s 中
	删除以零开头的连续零字符，注意删除后顺序
	进行字符到数字的处理
	进行数字边界值的处理

代码展示(已验证)：

//leetcode 8.字符串转整数(中等)
class Solution {
    public int myAtoi(String str) {
        if(str.length()==0)//检查字符串是不是为空
            return 0;

        str = str.trim();//去除字符串首尾空格
        
        if(str.length()==0)//判定字符串全为空格的情况
            return 0;
        
        StringBuilder s = new StringBuilder("");//初始化String类
        int flag = 1,m=0,num=0;

        //如果首字母不是数字字符和减号、加号字符，直接返回0，
        if(str.charAt(0) != 45 && str.charAt(0) != 43 && str.charAt(0)<48 && str.charAt(0)>57)
            return num;
        // 判定第一个合法字符是否为 - 号
        if(str.charAt(0) == 45)
        {
            flag = -1;
        }
        if(str.charAt(0) == 43)
//            flagplus = 1;
            m += 1;
        // 在第一个合法字符为 - 号，进行后续字符处理
        if(flag == -1)
            m += 1;

        // 将连续数字字符加入到 s 中
        for(int i=m;i<str.length();i++)
        {
            if(str.charAt(i)>=48 && str.charAt(i)<=57)
                s.append(str.charAt(i));
            else{
                break;
            }
        }

       
        //删除以零开头的字符中的连续零,注意删除后数据的顺序
        for(int i=0;i<s.length();)
            if(s.charAt(i)== '0')
            {
                s.delete(0,1);

            }
            else
                break;

        // 进行字符到数字的转化以及边界值的处理
        int[] nums = new int[s.length()];
        for(int i=0;i<s.length();i++)
        {
            nums[i] = s.charAt(i)-'0';
            num = num*10+nums[i];

            //如何判定数值过界 相除前后不相等 num!=num*10/10
        // //            if(flag==1 && num>=(int)Math.pow(2,31)-1)
        //             if(flag==1 && num!=num*10/10)
        //                 return Integer.MAX_VALUE-1;
        // //                return flag*(int)(Math.pow(2,31)-1);
        // //            else if(flag==-1 && num>=(int)Math.pow(2,31))
        //             else if(flag==-1 && num!=num*10/10)
        // //                return flag*(int)Math.pow(2,31);
        //                 return Integer.MIN_VALUE;
                        
            //判定过界数据进行输出
            if(flag>0 && i+1<s.length() && s.charAt(i+1)>='0' && s.charAt(i+1)<='9' && num > Integer.MAX_VALUE/10)
            return Integer.MAX_VALUE;
            if(flag>0 && i+1<s.length() && s.charAt(i+1)>='0' && s.charAt(i+1)<='9' && num == Integer.MAX_VALUE/10 && s.charAt(i+1)-'0' > Integer.MAX_VALUE%10) //借用余数进行判断
                return Integer.MAX_VALUE;
            if(flag<0 && i+1<s.length() && s.charAt(i+1)>='0' && s.charAt(i+1)<='9' && -num < Integer.MIN_VALUE/10)
                return Integer.MIN_VALUE;
            if(flag<0 && i+1<s.length() && s.charAt(i+1)>='0' && s.charAt(i+1)<='9' && -num == Integer.MIN_VALUE/10 && -(s.charAt(i+1)-'0') < Integer.MIN_VALUE%10)
                return Integer.MIN_VALUE;

        }

        // 输出数字
//        return 0;
        return flag*num;
    }
}

泡泡：

相对来说，里面要注意的细节还是挺多的，因为字符串的不同，造成的字符合法性和多样性也就更加复杂，
可以想一下，如果是自己来写测试用例i的话，应该要怎么分类，怎么写
	
关于边界值的处理这一块，需要注意一下，因为以后估计还会用到。