判断一个字符串是否是数值

Validate if a given string is numeric.

Some examples:
"0" => true
" 0.1 " => true
"abc" => false      不能为全字母
"1 a" => false     不能含有字母(e另外算)
"2e10" => true    可以含有e科学表达式表示的数
"e9"=>false   科学表达式前面不能没有数值，就是e前面的数不能省略
"0.e1"=>false       用科学表达式表示时，.前面不能为0
".e1"=>false         用科学表达式表示时，.前面不能为空
"46.e3"=>true     . 前面可以是不为0的数
"6ee"=>false      很明显
"8..e4"=>false     点数不能大于1
"e."=>false  e后面不能含有小数点
".2e81"=>true 

Note: It is intended for the problem statement to be ambiguous. You should gather all requirements up front before implementing one.

先给出我自己的解法吧，比较乱：

public boolean isNumber(String s)
	{
		boolean flag = true;
		// 先进行除前后空格
		s = s.trim();
		if (s == null || s.equals(""))
			return false;
		// 判断+，-号是不是在第一位出现
		if (s.substring(0, 1).equals("+") || s.substring(0, 1).equals("-"))
			s = s.substring(1);
		// 进行字符串截取,.和e除外
		int countOfe = 0;// 统计e出现的次数，只能出现一次
		String[] number =
		{ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ".", "e" };
		for (int i = 0; i < s.length(); i++)
		{
			int mark = 0;
			String ch = s.substring(i, i + 1);
			for (String str : number)
			{
				if (ch.equals(str))
				{
					mark = 1;
					break;
				}
				// 如果e出现
				if (ch.equals("e"))
				{
					countOfe++;
					mark = 1;
					// 判断e后面出现+号的情况
					if ((i + 2) <= s.length()
							&& s.substring(i + 1, i + 2).equals("+"))
					{
						i++;
					}
					// 判断e后面出现-号的情况
					else if ((i + 2) <= s.length()
							&& s.substring(i + 1, i + 2).equals("-"))
					{
						i++;
					}
					break;
				}
			}
			if (mark == 0 || countOfe > 1)
			{
				return false;
			}
		}
		// 判空
		if (s == null || s.equals(""))
			return false;
		// 处理小数点的情况(没e的情况)
		if (s.indexOf(".") >= 0 && s.indexOf("e") < 0)
		{
			int point = 0;
			// 小数点可以在第一位和可以在最后一位
			// 如果只有一个小数点，没有其他的数字
			if (s.length() == 1)
				return false;
			// 如果小数点个数大于1
			for (int i = 0; i < s.length(); i++)
			{
				if (s.subSequence(i, i + 1).equals("."))
					point++;
			}
			if (point > 1)
				return false;
			return true;
		}
		// 处理e的情况
		if (s.indexOf("e") >= 0)
		{
			// 点数不能多于一个
			if (s.indexOf(".") >= 0)
			{
				int point = 0;
				for (int i = 0; i < s.length(); i++)
				{
					if (s.subSequence(i, i + 1).equals("."))
						point++;
				}
				if (point > 1)
					return false;
			}
			// 点出现在e的前面一位的情况
			if (s.indexOf(".") >= 0 && s.indexOf(".") + 1 == s.indexOf("e"))
			{
				if (s.substring(0, s.indexOf(".")).equals("0")
						|| s.substring(0, s.indexOf(".")).equals(""))
					return false;
			}

			// 假如e出现在最后一位或第一位
			if (s.indexOf("e") == s.length() - 1 || s.indexOf("e") == 0)
				return false;
			// e后面出现“+”或“-”的情况
			else if (s.indexOf("+") == s.length() - 1
					|| s.indexOf("-") == s.length() - 1)
				return false;
			// e后面的数字有小数点的情况
			else if (s.indexOf(".") > 0
					&& s.substring(s.indexOf("e")).indexOf(".") >= 0)
				return false;
			else
				return true;
		}

		return flag;
	}

然后看到网上有大神用的是有限状态机，膜拜啊，附上代码，学习学习：

用有限状态机，非常简洁，不需要复杂的各种判断！

先枚举一下各种合法的输入情况：

1.空格+ 数字 +空格

2.空格+ 点 + 数字 +空格

3.空格+ 符号 + 数字 +　空格

4.空格 + 符号 + 点 +　数字　＋空格

5.空格 + (1, 2, 3, 4） + e +　(1, 2, 3, 4) +空格

组后合法的字符可以是：

1.数字

2.空格

有限状态机的状态转移过程：

起始为0：

　　当输入空格时，状态仍为0，

　　输入为符号时，状态转为3，3的转换和0是一样的，除了不能再接受符号，故在0的状态的基础上，把接受符号置为-1；

　　当输入为数字时，状态转为1, 状态1的转换在于无法再接受符号，可以接受空格，数字，点，指数；状态1为合法的结束状态；

　　当输入为点时，状态转为2，状态2必须再接受数字，接受其他均为非法；

　　当输入为指数时，非法；

状态1：

　　接受数字时仍转为状态1，

　　接受点时，转为状态4，可以接受空格，数字，指数，状态4为合法的结束状态，

　　接受指数时，转为状态5，可以接受符号，数字，不能再接受点，因为指数必须为整数，而且必须再接受数字；

状态2：

　　接受数字转为状态4；

状态3：

　　和0一样，只是不能接受符号；

状态4：

　　接受空格，合法接受；

　　接受数字，仍为状态4；

　　接受指数，转为状态5，

状态5：

　　接受符号，转为状态6，状态6和状态5一样，只是不能再接受符号，

　　接受数字，转为状态7，状态7只能接受空格或数字；状态7为合法的结束状态；

状态6：

　　只能接受数字，转为状态7；

状态7：

　　接受空格，转为状态8，状态7为合法的结束状态；

　　接受数字，仍为状态7；

状态8：

　　接受空格，转为状态8，状态8为合法的结束状态；

class Solution
{
public:
    bool isNumber(const char *s)
    {
        enum InputType
        {
            INVALID,    // 0
            SPACE,      // 1
            SIGN,       // 2
            DIGIT,      // 3
            DOT,        // 4
            EXPONENT,   // 5
            NUM_INPUTS  // 6
        };
        
        int transitionTable[][NUM_INPUTS] =
        {
            -1,  0,  3,  1,  2, -1,     // next states for state 0
            -1,  8, -1,  1,  4,  5,     // next states for state 1
            -1, -1, -1,  4, -1, -1,     // next states for state 2
            -1, -1, -1,  1,  2, -1,     // next states for state 3
            -1,  8, -1,  4, -1,  5,     // next states for state 4
            -1, -1,  6,  7, -1, -1,     // next states for state 5
            -1, -1, -1,  7, -1, -1,     // next states for state 6
            -1,  8, -1,  7, -1, -1,     // next states for state 7
            -1,  8, -1, -1, -1, -1,     // next states for state 8
        };
        
        int state = 0;
        while (*s != '\0')
        {
            InputType inputType = INVALID;
            if (isspace(*s))
                inputType = SPACE;
            else if (*s == '+' || *s == '-')
                inputType = SIGN;
            else if (isdigit(*s))
                inputType = DIGIT;
            else if (*s == '.')
                inputType = DOT;
            else if (*s == 'e' || *s == 'E')
                inputType = EXPONENT;
            
            state = transitionTable[state][inputType];
            
            if (state == -1)
                return false;
            else
                ++s;
        }
        
        return state == 1 || state == 4 || state == 7 || state == 8;
    }
};