表示数值的字符串

枚举各种类型判断

    public boolean isNumeric (String str) {
        if(str==null || str.length()==0) {
            return false;
        }
        boolean hasFlag = false;
        boolean hasDecimal = false;
        boolean hasE = false;
        boolean hasNum = false;
        for(int i=0;i<str.length();++i) {
            char c = str.charAt(i);
            if(c=='+' || c=='-') {
                if(hasFlag) {
                    return false;
                } else if(hasNum) {
                    return false;
                } else {
                    hasFlag = true;
                }
            } else if(c>='0' && c<='9') {
                hasNum = true;
            } else if(c=='e' || c=='E') {
                if(hasE) {
                    return false;
                }
                if(!hasNum) {
                    return false;
                }
                hasFlag = false;
                hasE = true;
                hasNum = false;
                hasDecimal = true;
            } else if(c=='.') {
                if(hasDecimal) {
                    return false;
                }
                hasDecimal = true;
            } else {
                return false;
            }
        }
        if(hasE && !hasNum) {
            return false;
        }
        if(hasDecimal && !hasNum) {
            return false;
        }
        if(hasFlag && !hasNum) {
            return false;
        }
        return true;
    }

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param str string字符串 
     * @return bool布尔型
     */
    bool isNumeric(string str) {
        // 时间复杂度O(N)，空间复杂度O(N)
        return isNumerci(str.c_str());
    }
    bool isNumerci(const char *str) {
        while (*str == ' ') ++str;
        bool numeric = scanInteger(&str);
        if (*str == '.') {
            ++str;
            numeric = scanUnsignedInteger(&str) || numeric;
        }
        if (*str == 'e' || *str == 'E') {
            ++str;
            numeric = numeric && scanInteger(&str);
        }
        while (*str == ' ') ++str;
        return numeric && *str == '\0';
    }
    bool scanInteger(const char **str) {
        if (**str == '+' || **str == '-') ++(*str);
        return scanUnsignedInteger(str);
    }
    bool scanUnsignedInteger(const char **str) {
        const char *before = *str;
        while (**str != '\0' && **str >= '0' && **str <= '9') ++(*str);
        return *str > before;
    }
};

import java.util.*;

/**
思路：
1.先删除字符串首尾的空格字符
2.先判断整数、再判断小数、再判断科学计数法，这个顺序不能乱。
*/
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param str string字符串 
     * @return bool布尔型
     */
    public boolean isNumeric (String str) {
        
        if(str == null || "".equals(str)){
            return false;
        }
        
        //删除首尾字符串的空格
        str = deleteKongGe(str);
        if( str == null){
            return false;
        }
        
        return judgeInteger(str) || judgeDecimal(str) || judgeScientificNotation(str);
    }
    
    //删除字符串的前后空格
    public String deleteKongGe(String str){
        
        char[] c = str.toCharArray();
        
        //定位-1用来判断全部是空格的极端情况
        int firstIndex = -1;
        
        int laterIndex = c.length - 1;
        
        //计算从前数第一个非空格字符索引
        for(int i = 0 ; i < c.length ; i++){
            //32表示空格
            if(c[i] != 32){
                firstIndex = i;
                break;
            }
        }
        
        //计算从后数第一个非空格字符索引
        for(int j = laterIndex ; j >= 0 ; j--){
            if(c[j] != 32){
                laterIndex = j;
                break;
            }
        }
        
        //若全是空格返回null否则返回…………
        return (firstIndex == -1) ? null : str.substring(firstIndex,laterIndex + 1);
    }
    
    //判断是否是整数
    public boolean judgeInteger(String str){
        
        //删除正负号
        if((str.charAt(0) == '+' || str.charAt(0) == '-')  && str.length() > 1){
            str = str.substring(1,str.length());
        }
        
        return judgeNumber(str);
    }
    
    //判断是否是小数
    public boolean judgeDecimal(String str){
        
        //删除正负号
        if((str.charAt(0) == '+' || str.charAt(0) == '-') && str.length() > 1){
            str = str.substring(1,str.length());
        }
        
        //3.1 至少一位数字，后面跟着一个点‘.’
        if(str.charAt(str.length() - 1) == '.'){
            //将尾‘.’删掉
            str = str.substring(0,str.length() - 1);
            
            return judgeNumber(str);
        }
        
        //3.3 一个点 '.' ，后面跟着至少一位数字
        if(str.charAt(0) == '.'){
            //将头‘.’删掉
            str = str.substring(1,str.length());
            
            return judgeNumber(str);
        }
        
        //3.2 至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字
        if(str.contains(".")){
            int index = str.indexOf(".");
            //‘.’前面和后面至少应该有一位
            if(index > 0 || index < (str.length() - 1)){
                //将中间的‘.’删掉
                String str1 = str.substring(0,str.indexOf("."));
                String str2 = str.substring(str.indexOf(".") + 1);
                str = str1 + str2;
            
                return judgeNumber(str);
            }
            return false;
        }
        
        return false;
    }
    
    //判断是否是科学计数法
    public boolean judgeScientificNotation(String str){
        
        //科学计数法至少要三位
        if(str.length() < 3){
            return false;
        }
        
        int eIndex = str.indexOf("e") != -1 ? str.indexOf("e") : str.indexOf("E");
        
        if(eIndex == -1){
            return false;
        }
        
        //eIndex前面和后面至少应该有一位
        if(eIndex > 0 && eIndex < (str.length() - 1 )){
            //前半部分
            String fontStr = str.substring(0,eIndex);
            //后半部分
            String backStr = str.substring(eIndex + 1, str.length());
            
            //一个整数或者小数后面跟着一个整数
            return (judgeInteger(fontStr) || judgeDecimal(fontStr)) && judgeInteger(backStr);
        }
        
        return false;
    }
    
    //判断是否是纯数字
    public boolean judgeNumber(String str){
        
        //不满足至少有一位数字的要求
        if("".equals(str)){
            return false;
        }
        
        char[] c = str.toCharArray();
        
        for(int i = 0 ; i < c.length ; i++){
            if(c[i] < 48 || c[i] > 57){
                return false;
            }
        }
        
        return true;
    }
   
}

//代码很长，但是简单易懂，写起来很快的，不会把'.''e'凑一起写头疼
//将判断条件提取为几个相同的函数：去除前后空格+是否至少包含一位数字+是否是整数
//                           +是否是小数+是否是科学计数法的数 

import java.util.*;
public class Solution {
    public boolean isNumeric (String str) {
        // write code here
        String trimString = trim(str);         //去除前后空格
        int len = trimString.length();
        if (len == 0) {       
            return false;
        }
        return isScientificNumber(trimString)  //检测去除空格后的字符串是不是科学计数法
            || isInteger(trimString, 0, len-1) //或者整数或者小数
            || isDecimal(trimString, 0, len-1);
        
    }
    //去除字符串前后空格
    private String trim(String str) {
        int left = 0, right = str.length()-1;
        while (left <= right) {
            if (str.charAt(left) == ' ') {
                left ++;
            } else {
                break;
            }
        }
        while (left <= right) {
            if (str.charAt(right) == ' ') {
                right --;
            } else {
                break;
            }
        }
        if (left <= right) {
            return str.substring(left, right+1);
        }
        return "";
    }
    //检测字符串是不是整数
    private boolean isInteger(String str, int left, int right) {
        if (left > right) return false;
        if (str.charAt(left) == '+' || str.charAt(left) == '-') {
            left++;
            if (left > right) return false;
        }
        return containsOneNumber(str, left, right) ? true : false;
    }
    //检测字符串是不是小数
    private boolean isDecimal(String str, int left, int right) {
        if (left > right) return false;
        if (str.charAt(left) == '+' || str.charAt(left) == '-') {
            left ++;
            if (left > right) return false;
        }
        int start = left;
        boolean mark = false;                      //标记是否有'.'
        for (int i=left; i<=right; ++i) {
            if (str.charAt(i) == '.') {
                start = i;
                mark = true;
                break;
            }
        }
        if (mark) {
            if (start == right) {
                return containsOneNumber(str, left, start-1);
            } else if (start == left){
                return containsOneNumber(str, left+1, right);
            } else {
                return containsOneNumber(str, left, start-1) && containsOneNumber(str, start+1, right);
            }
        }
        return false;
    }
    //检测字符串是不是至少包含一位数字
    private boolean containsOneNumber(String str, int left, int right) {
        if (left > right) return false;
        while (left <= right) {
            if (str.charAt(left) < '0' || str.charAt(left) > '9') {
                return false;
            }
            left ++;
        }
        return true;
    }
    //
    private boolean isScientificNumber(String str) {
        boolean mark = false;                                     //标记是否有'e'或'E'
        int start = 0;
        for (int i=0; i<str.length(); ++i) {
            if (str.charAt(i) == 'e' || str.charAt(i) == 'E') {
                start = i;
                mark = true;
                break;
            }
        }
        if (mark) {
            return (isInteger(str, 0, start-1) || isDecimal(str, 0, start-1))
                && isInteger(str, start+1, str.length()-1);
        }
        return false;
    } 
}

class Solution:
    def is_inter(self, s): #是否为整数
        if len(s) == 0:
            return False
        for it in s:
            if it < '0'&nbs***bsp;it > '9':
                return False
        return True
    
    def is_with_flag_inter(self, s): # 带符号整数
        if len(s) == 0:
            return False
        if s[0] == '+'&nbs***bsp;s[0] == '-':
            s = s[1:]
        return self.is_inter(s)
    
    def is_float(self, s): # 浮点数
        s = s.split('.')
        if len(s) > 2&nbs***bsp;len(s) == 0:
            return False
        flag = self.is_with_flag_inter(s[0])
        special_flag = len(s[0]) == 1 and (s[0] in ['+', '-']) and len(s) == 2 and self.is_inter(s[1])
        # special_flag  -.123
        return flag and (len(s)==1&nbs***bsp;self.is_inter(s[1]))&nbs***bsp;special_flag
        
    
    def isNumeric(self , s):
        s = s.replace('E', 'e')
        s = s.split('e')
        if len(s) == 0&nbs***bsp;len(s) > 2:
            return False
        flag = self.is_float(s[0])
        if len(s) == 2:
            flag = flag and self.is_with_flag_inter(s[1])
        return flag

考虑出现.+-eE的限制条件

    public boolean isNumeric (String str) {
        char[] chars = str.toCharArray();
        boolean point = false;//表示小数点是否已存在
        boolean e = false;//表示e是否已存在
        boolean lOperator = false;//表示e左边运算符是否已存在
        boolean rOperator = false;//表示e右边运算符是否已存在
        int len = chars.length;
        int eIndex = len;//e出现的位置
        for (int i = 0; i < len; i++) {
            if (chars[i] == '.'){
                if (point || i > eIndex) return false;//小数点只能有一个，并且必须在e前面
                point = true;
            }else if (chars[i] == 'e' || chars[i] == 'E'){
                if (e || i == 0 || i == len-1) return false;//e只能有一个，并且不能在首位和末位
                eIndex = i;
                e = true;
            }else if (chars[i] == '+' || chars[i] == '-'){
                if (i < eIndex){
                    if (lOperator || i != 0) return false;//e左边运算符只能有一个，并且只能在第一位
                    lOperator = true;
                }else {
                    if (rOperator || i - eIndex != 1) return false;//e右边运算符只能有一个,并且只能紧挨e后面
                    rOperator = true;
                }
            }else if (chars[i] >= '0' && chars[i] <= '9'){//数字出现在哪都可以
                continue;
            }else {//不能出现.+-eE和数字以外的字符
                return false;
            }
        }
        return true;
    }

C++ 题解

class Solution {
public:
    bool isNumeric(string str) {
        if(str.empty()) return false;

        int pos = 0; //字符串索引

        while(str[pos] == ' ') pos++; //开头去除空格

        bool isCorrcet = false; //整数部分
        if(str[pos] == '+' || str[pos] == '-') pos++;
        while(str[pos]!='\0' && str[pos] >= '0' && str[pos] <= '9'){
            isCorrcet = true; //必须是数字
            pos++;
        }

        if(str[pos] == '.'){
            pos++; //小数部分
            while(str[pos]!='\0' && str[pos] >= '0' && str[pos] <= '9'){
                isCorrcet = true; //必须是数字
                pos++;
            }
        }

        if(str[pos] == 'e' || str[pos] == 'E'){
            pos++; //指数数部分
            if(str[pos] == '+' || str[pos] == '-') pos++;
            if(str[pos] == '\0' || str[pos] < '0' || str[pos] > '9') isCorrcet = false;
            while(str[pos]!='\0' && str[pos] >= '0' && str[pos] <= '9'){
                isCorrcet = isCorrcet && true; //必须是数字
                pos++;
            }
        }

        while(str[pos] == ' ') pos++; //结尾去除空格

        //最终长度一致 && 整数和小数必须有一个存在 && 若有指数必须格式正确
        return (pos == str.size()) && isCorrcet;
    }
};

只管写代码，其他的都交给布兰登艾奇

function isNumeric( str ) {
    // write code here
    return +str == str && str.trim() !== ''
}