将字符串转化为整数

    public int atoi (String s) {
        if (s == null) {
            return 0;
        }
        s = s.trim();
        if (s.length() == 0) return 0;
        int sign = 1;
        int index = 0;
        if (s.charAt(0) == '+' || s.charAt(0) == '-') {
            sign = s.charAt(0) == '+' ? 1 : -1;
            index = 1;
        }
        int res = 0;
        while (index < s.length()) {
            char c = s.charAt(index);
            if (c - '0' < 0 || c - '0' > 9) {
                break;
            }
            int tempRes = res * 10 + (c - '0');
            if (tempRes / 10 != res) {
                return sign > 0 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
            }
            res = tempRes;
            index++;
        }
        return res * sign;
    }

实际上这个题目测试用例还是不完善。少了e这个字样。因此只需要判断空串、符号、溢出即可。

import java.util.*;
public class Solution {
    public int atoi (String str) {
         int i=0;
         int flag=0;
        if(str.isEmpty())return 0;
        while(true){
            if(str.charAt(i)=='+'||str.charAt(i)=='-')
            {    
                 if(str.charAt(i)=='-')
                     flag=1;
                 i++;
                 break;
            }  
            else if(str.charAt(i)='0'){
                break;
            }
            else i++;
        }
        int start = i;
        if(i<str.length()){
            int highbit = str.charAt(i)-'0';
            i++;
            for(;i<str.length();++i){
               // sum =sum*10+str.charAt(i)-'0';
                 if(!(str.charAt(i)='0'))break;
                if(i-start>=10){
                    if(flag ==1)
                        return -2147483648;
                    return 2147483647;
                }
                highbit = highbit*10+str.charAt(i)-'0';
            }
            return flag==1?-highbit:highbit;
        }
        return 0;
    }
}

public int atoi (String str) {
        // write code here
        StringBuilder s = new StringBuilder(str);
        if(s.length()==0){
            return 0;
        }
        while (s.charAt(0)==' '){
            s.deleteCharAt(0);
        }
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)>89){
                s.delete(i,s.length());
            }
        }
        
        if(s.length()>10 && s.charAt(0)!='-'){
            return Integer.MAX_VALUE;
        }else if(s.length()>11 && s.charAt(0)=='-'){
            return -Integer.MAX_VALUE-1;
        }
        return Integer.parseInt(String.valueOf(s));
    }

import java.util.*;


public class Solution {
    /**
     * 
     * @param str string字符串 
     * @return int整型
     */
    public int atoi (String str) {
        // write code here
        long n=0;
        int j=0;
       if(str==""||str.length()<1)
           return 0;
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)=='-'){
                j=1;
                continue;
            }
             if(str.charAt(i)=='+'||str.charAt(i)=='-'||str.charAt(i)==' '){
                continue;
             }else if(str.charAt(i)<'0'||str.charAt(i)>'9'){
                 break;
             }else
            n=n*10+str.charAt(i)-'0';
        }
        if(j==1){
            long k;
            k=n;
            n=0-k;
        }
        if(n>Integer.MAX_VALUE){
            return Integer.MAX_VALUE;
        }else if(n<Integer.MIN_VALUE){
            return Integer.MIN_VALUE;
        }
        return (int)n;
    }
}

import java.util.*;
public class Solution {
    /**
     * 
     * @param str string字符串 
     * @return int整型
     1.正负号；2.中间存在字母（只取字母前的数字）;3.溢出;4.前后空格
     */
    public int atoi (String str) {
        // write code here
    //若字符串为空或去除前后空格后为空，返回0
    if (str == null||str.trim().length() == 0 )
                return 0;
            //处理掉前后空格并转化为字符串数组
            char[] arr = str.trim().toCharArray();

            int sign = 1, index = 0;
            //判断正负号
            if (arr[0] == '+')
                index++;
            if (arr[0] == '-') {
                sign = -1;
                index++;
            }

        int num = 0;
        for (int i = index; i < arr.length; i++) {
            if (arr[i] - '0' >= 0 && arr[i] - '9' <= 0) {
                //如果当前运算会越界的时候，直接输出结果
                if (num >= Integer.MAX_VALUE/ 10   ) {//注意此处得/10，否则马上要超范围时，下一此更新num会数字跳变
                    if (sign > 0)
                        return Integer.MAX_VALUE;
                    else
                        return Integer.MIN_VALUE;
                }
 
                num = 10 * num + arr[i] - '0';//数字放在判断超出范围之后进行，防止马上要超范围时u，
                                                                      //  数字更新带来符号跳变           
                             } else
                //如果是字母，跳出循环
                break;
        }
 
        return num * sign;
    }
}

import java.util.*;
public class Solution {
    /**
     * 
     * @param str string字符串 
     * @return int整型
     1.正负号；2.中间存在字母（只取字母前的数字）;3.溢出;4.前后空格
     */
    public int atoi (String str) {
        // write code here
        //若字符串为空或去除前后空格后为空，返回0
         if(str==null||str.trim().length()==0)
             return 0;
         //将字符串去除前后空格后转化为字符串数组
         char[] arr=str.trim().toCharArray();
        //判断正负
        int sign=1;
        int i=0;
        long num=0;
        int res=0;
        if(arr[i]=='-')
        {
            sign=-1;
            i++;
        }
        if((arr[i]=='+'))
        {
            sign=1;
            i++;
        }
        //判断后续
        for(int j=i;j<str.trim().length();j++)
        {
            //若为数字
            
            if(arr[j]>='0'&&arr[j]<='9')
            {   //若超过int的范围
                
              num=num*10+(arr[j]-'0');//num为long类型，保证本次在超过Integer.MAX_VALUE时，真实值不会跳变为负
              if(num>=Integer.MAX_VALUE)
                {
                    if(sign==1)
                        return Integer.MAX_VALUE;
                    else
                        return Integer.MIN_VALUE;
                }
                res=(int)(sign*num);//res为最终输出，在不超过Integer.MAX_VALUE时，输出结果
           }
            else
                break;
        }
        return res;
        
    }
}

    boolean isNumber(char target) { return target >= '0' && target <= '9'; }
    //"+" "-" "+/" long(长度帮忙判断)，int(用long) 越界  前面全是0  随时防止越界-加i<str.length()
    public int atoi(String str) {
        char[] charArray = str.toCharArray();
        int i=0,sign=1;
        while (i<str.length()&&charArray[i]==' ') i++;        //前面的空格全部跳过
        if (i==str.length()) return 0; //看看是不是到最后了
        //处理正负号
        if (charArray[i] == '-') {
            sign = -1;
            i++;
        }
        else if (charArray[i]=='+') i++; //正号跳过
        int res = 0;
        while (i < str.length() && isNumber(charArray[i])) {
            int curNum = charArray[i++] - '0';
            if (res>Integer.MAX_VALUE/10||res==Integer.MAX_VALUE/10&&curNum>Integer.MAX_VALUE%10) return Integer.MAX_VALUE;
            //后面Integer.MIN_VALUE的负号加在哪里有讲究：必须让这个值为8 -(Integer.MIN_VALUE)%10结果是7 因为中间这个变正数后会溢出
            if (res<Integer.MIN_VALUE/10||res==Integer.MIN_VALUE/10&&curNum>-(Integer.MIN_VALUE%10)) return Integer.MIN_VALUE;
            //每次把sign乘进去 这样可以保证循环结束后 结果一定是完全的负数 因为前置结果负数乘10+负数 仍是正确的负数
            res = res * 10 +sign*curNum;
        }
        //考虑溢出
        return res;
    }

import java.util.*;


public class Solution {
    /**
     * 
     * @param str string字符串 
     * @return int整型
     */
    public int atoi (String str) {
        // write code here
        StringBuilder sb = new StringBuilder();
        char[] ch = str.trim().toCharArray();
        for(int i=0; i<ch.length; i++){
            if(i==0 && (ch[i]=='-' || ch[i]=='+')){
                sb.append(ch[i]);
                continue;
            }
            if(ch[i]>='0' && ch[i]<='9'){
                sb.append(ch[i]);
            }else{
                break;
            }
        }
        if(sb.length()>0){
            long l = Long.parseLong(sb.toString());
            if(l >= Integer.MAX_VALUE){
                return Integer.MAX_VALUE;
            }else if(l <= Integer.MIN_VALUE){
                return Integer.MIN_VALUE;
            }
            return Integer.parseInt(sb.toString());
        }
        return 0;
    }
}

import java.util.*;
public class Solution {
    public int atoi (String s) {
        if (s == null || s.length() == 0) return 0;
        int len = s.length();
        // 忽略前导空格
        int index = 0;
        while (index < len && s.charAt(index) == ' ') index++;
        if (index == len) return 0;

        // 检查符号
        int symbol = s.charAt(index) == '-' ? -1 : 1;
        if (s.charAt(index) == '-' || s.charAt(index) == '+') index++;

        // 读数字部分
        int num = 0;
        while (index < len){
            char c = s.charAt(index++);
            // 非数字
            if (c < '0' || c > '9') break;
            // 前导0
            if (num == 0 && c == '0') continue;
            // 溢出,num*10+c-'0' > Integer.MAX_VALUE ——————>  Integer.MAX_VALUE/10-(c-'0')/10 < num  ————> num > Integer.MAX_VALUE/10
            // num == Integer.MAX_VALUE/10就比个位数
            if (num > Integer.MAX_VALUE/10 || num == Integer.MAX_VALUE/10 && c-'0' > Integer.MAX_VALUE%10) {
                return symbol == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
            }
            num = num*10+c-'0';
        }
        return num*symbol;
    }
}

 public int atoi (String str) {
         str=str.trim();
	        if(str.isEmpty())
	            return 0;
	        String s="";
	        if(str.startsWith("+")||str.startsWith("-")) {
	        	s=str.substring(0, 1);
	        	str=str.substring(1);
	        }
	        for(int i=0;i<str.length();i++) {
	        	char c=str.charAt(i);
	        	if(Character.isDigit(c)) {
	        		s+=Character.toString(c);
	        	}else {
	        		break;
	        	}
	        }
	        if(s.isEmpty())
	            return 0;
            if(s.equals("+")||s.equals("-")) {
	        	return 0;
	        }
	        long n=Long.parseLong(s);
	        if(n>Integer.MAX_VALUE)
	        	return Integer.MAX_VALUE;
	        if(n<Integer.MIN_VALUE)
	        	return Integer.MIN_VALUE;
	        return (int)n;
    }

import java.util.*;


public class Solution {
    // 预处理：先trim一下去掉首尾无用空格
    // 1.读取最长数字字符串：如果是正号/负号开头，继续向后读取直到遇到非数字
    //           如果是数字开头，直接向后读取直到遇到非数字
    //           如果都不是，则直接出错（返回0）
    // 2.解析数字：根据正负数，使用 乘10 + 余 * 正1/负1 的思想，需特别注意边界值计算
    //           当前数为正数，若当前数 > Integer.MAX_VALUE/10，
    //                或当前数 == Integer.MAX_VALUE/10 且 待加入数大于7 则返回Integer.MAX_VALUE
    //           当前数为负数，若当前数 < Integer.MIN_VALUE/10，
    //                或当前数 == Integer.MIN_VALUE/10 且 待加入数大于8 则返回Integer.MIN_VALUE
    //           更新当前数 乘10 + 余 * 正1/负1
    public int atoi(String str) {
        /* 预处理 */
        // 边界判断
        str = str.trim();
        if (str == "" || str.length() == 0)
            return 0;

        /* 读取最长数字字符串 */
        // 记录除去符号后初始数字读取位置
        char[] chs = str.toCharArray();
        int flag = 0;
        if (chs[0] == '+' || chs[0] == '-'){
            flag = 1;
        }else if(chs[0] <= '9' || chs[0] >= '0'){
            flag = 0;
        }else{
            return 0;
        }
        // 获取可达最长数字字符串长度
        int num = flag;
        for ( ; num < chs.length ; num++ ){
            if (chs[num] > '9' || chs[num] < '0')
                break;
        }

        /* 解析数字,flag为第一位数字，num数字串长 */
        int res = 0;
        int mark = chs[0] == '-' ? -1 : 1 ;
        for (int i = flag; i < num ; i++){
            int cur = Integer.valueOf(chs[i] - '0');
            // 正数
            if (mark == 1 && res > Integer.MAX_VALUE/10 || res == Integer.MAX_VALUE/10 && cur > 7)
                return Integer.MAX_VALUE;
            // 负数
            if (mark == -1 && res < Integer.MIN_VALUE/10 || res == Integer.MIN_VALUE/10 && cur > 8)
                return Integer.MIN_VALUE;
            res = res * 10 + cur * mark;
        }
        return res;
    }
}

import java.util.*;


public class Solution {
    /**
     * 
     * @param str string字符串 
     * @return int整型
     */
    public int atoi (String str) {
        // write code here
        String temp = str.trim();
        if(temp.equals("")){
            return 0;
        }
        char[] chs = temp.toCharArray();
        int i = 0;
        for(;i < chs.length; i++){
            if(chs[i]!='+' && chs[i]!='-' && (chs[i]<'0' || chs[i]>'9')){
                break;
            }
        }
        // 使用try-catch做出溢出判断
        try{
            return Integer.valueOf(temp.substring(0,i));
        }catch(Exception e){
            if(temp.charAt(0)=='-'){
                return Integer.MIN_VALUE;
            }else{
                return Integer.MAX_VALUE;
            }
        }
    }
}