<span style="color:#ff6666;">/**
	 * 判断当前字符或字符串是否是数字
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isNumber(String str) {
		return str.startsWith("0") || str.startsWith("1")
				|| str.startsWith("2") || str.startsWith("3")
				|| str.startsWith("4") || str.startsWith("5")
				|| str.startsWith("6") || str.startsWith("7")
				|| str.startsWith("8") || str.startsWith("9")
				|| str.startsWith(".");

	}</span>

         /**
	 * 分析四则运算表达式，将数字与运算符进行分解
	 */
	public static List<String> parse(String exp) {
		int length = exp.length();

		// 四则运算解析
		List<String> expList = new ArrayList<String>();

		String tempStr = "";
		for (int i = 0; i < length; i++) {
			String tempChar = exp.substring(i, i + 1);
			if (DataUtils.isNumber(tempChar)) {// 如果是数字的话
				tempStr += tempChar;
			} else {
				if (!tempStr.equals("")) {// 遇到运算符，判断存储的数字字符串是否为空
					expList.add(tempStr);
				}
				expList.add(tempChar);
				tempStr = "";
			}
		}
		if (!tempStr.equals("")) {// 保证最后一个非空的数字字符串添加到expList中
			expList.add(tempStr);
		}
		return expList;
	}

         /**
	 * 将分解后的四则运算列表构建成逆波兰表达式列表
	 */
	public static List<String> createRPN(List<String> expList) {
		Stack stack = new Stack();
		// 存放逆波兰表达式
		List<String> rpnList = new ArrayList<String>();

		int length = expList.size();
		for (int i = 0; i < length; i++) {
			String c = expList.get(i);

			// 如果是数字，直接放到逆波兰链表的最后
			if (DataUtils.isNumber(c)) {
				rpnList.add(c);
			} else {
				// 如果不是数字
				// 如果是左括号，则直接将左括号压入栈
				if (OperatorUtils.isParenthesesStart(c)) {
					stack.push(c);
				} else if (OperatorUtils.isParenthesesEnd(c)) {
					// 如果是右括号

					// 进行出栈操作，直到栈为空或者遇到第一个左括号
					while (!stack.isEmpty()) {
						// 将栈顶字符串做出栈操作
						String tempC = stack.pop();
						if (!tempC.equals(OperatorUtils.OPSTART)) {
							// 如果不是左括号，则将字符串直接放到逆波兰链表的最后
							rpnList.add(tempC);
						} else {
							// 如果是左括号，退出循环操作
							break;
						}
					}
				} else {
					// 如果栈内为空
					if (stack.isEmpty()) {
						// 将当前字符串直接压栈
						stack.push(c);
					} else {
						// 如果栈不为空

						// 比较栈顶字符串与当前字符串的优先级
						if (OperatorUtils.compare(stack.top(), c)) {
							// 如果栈顶元素的优先级大于当前字符串,则进行出栈操作
							// 将栈顶元素直接放到逆波兰链表的最后
							// 直到栈内为空，或者当前元素的优先级不小于栈顶元素优先级
							while (!stack.isEmpty()
									&& OperatorUtils.compare(stack.top(), c)) {
								rpnList.add(stack.pop());
							}
						}
						// 将当前字符串直接压栈
						stack.push(c);
					}
				}

			}
		}

		// 如果栈不为空，则将栈中所有元素出栈放到逆波兰链表的最后
		while (!stack.isEmpty()) {
			rpnList.add(stack.pop());
		}
		return rpnList;
	}