剑指Offer-把字符串转换成整数

将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0
输入描述:

输入一个字符串,包括数字字母符号,可以为空

输出描述:

如果是合法的数值表达则返回该数字，否则返回0

public static class Solution {
        public static boolean flag;
        public static int StrToInt(String str) {
            flag = false;
            //判断输入是否合法
            if (str == null || str.trim().equals("")) {
                flag = true;
                return 0;
            }
            // symbol=0,说明该数为正数;symbol=1，该数为负数;start用来区分第一位是否为符号位
            int symbol = 0;
            int start = 0;
            char[] chars = str.trim().toCharArray();
            if (chars[0] == '+') {
                start = 1;
            } else if (chars[0] == '-') {
                start = 1;
                symbol = 1;
            }
            int result = 0;
            for (int i = start; i < chars.length; i++) {
                if (chars[i] > '9' || chars[i] < '0') {
                    flag = true;
                    return 0;
                }
                int sum= result * 10 + (int) (chars[i] - '0');
                if((sum-(int) (chars[i] - '0'))/10!=result){
                    flag=true;
                    return 0;
                }
                result=result * 10 + (int) (chars[i] - '0');
            }
            result = (int) Math.pow(-1, symbol) * result;
            return result;
        }
    }

JDK源码 Integer.valueOf(str)，还带进制的，强大的一批:

public static class Solution {
        public static int StrToInt(String str) throws Exception {
            return parseInt(str,10);
        }
        public static int parseInt(String s, int radix)
                throws Exception
        {
            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 new Exception();

                    if (len == 1) // Cannot have lone "+" or "-"
                        throw new Exception();
                    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 new Exception();
                    }
                    if (result < multmin) {
                        throw new Exception();
                    }
                    result *= radix;
                    if (result < limit + digit) {
                        throw new Exception();
                    }
                    result -= digit;
                }
            } else {
                throw new Exception();
            }
            return negative ? result : -result;
        }
    }