[置顶] Java表达式求值

Java表达式求解实现，用到栈先进后出的特点，详见代码

public float evaluation(String textField) {
		StringBuilder str = new StringBuilder();
		Stack<Float> stk = new Stack<Float>(); // 用于寄存 *** 作数或结果
		Stack<Character> stk2 = new Stack<Character>(); // 用于寄存运算符
		stk2.push('#'); // 在运算符栈初始一个'#'，用于第一个运算符比较优先级
		char c;
		// 依次读入字符
		for (int i = 0; i < textField.length(); i++) {
			boolean isbeg = false;// 是否为负数或正数 *** 作符
			c = textField.charAt(i);
			if ((c >= '0' && c <= '9') || c == '.') { // 数字或小数点直接组合
				str.append(c);
			} else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '('
					|| c == ')') {
				if ((c == '+' || c == '-') && stk.empty() && str.length() == 0) {
					str.append(c);
					isbeg = true;
				} else if (str.length() != 0) {
					try {
						float f = Float.parseFloat(str.toString());
						stk.push(f);
					} catch (Exception e) {
						flag = false;
						return -1;
					}
					str.delete(0, str.length());
				}
				// 如果读入 *** 作符优先级小于 *** 作符栈顶元素优先级，进行计算，并将结果保存如 *** 作数栈
				if (judge(stk2.peek()) >= judge(c) && !isbeg) {
					try {
						float b = Float.parseFloat(stk.pop().toString());
						float a = Float.parseFloat(stk.pop().toString());// 取出 *** 作数栈两数
						char c1 = stk2.pop();// 取出 *** 作符
						if (c != ')') {
							stk2.push(c); // 低优先级 *** 作符入栈
						}
						switch (c1) {
						case '+':
							stk.push(a + b);
							break;
						case '-':
							stk.push(a - b);
							break;
						case '*':
							stk.push(a * b);
							break;
						case '/':
							stk.push(a / b);
							break;

						default:
							break;
						}
					} catch (Exception e) {
						flag = false;
						return -1;
					}

					if (c == ')') {
						while (stk2.peek() != '#') {
							float b = Float.parseFloat(stk.pop().toString());
							try {
								float a = Float
										.parseFloat(stk.pop().toString());// 取出 *** 作数栈两数
								char c1 = stk2.pop();// 取出 *** 作符
								switch (c1) {
								case '+':
									stk.push(a + b);
									break;
								case '-':
									stk.push(a - b);
									break;
								case '*':
									stk.push(a * b);
									break;
								case '/':
									// if (b == 0) {
									// 除数为零
									// } else {
									stk.push(a / b);

									// }
									break;
								default:
									break;
								}
							} catch (Exception e) {
								flag = false;
								return -1;
							}
						}
						// stk2.pop();// d出')'
						stk2.pop();// d出'#'
						stk2.pop();// d出'('
					}
				} else if (!isbeg) {
					stk2.push(c);
					if (c == '(') {
						stk2.push('#');
					}
				}
			} else {
				flag = false;
				return -1;
			}
		}
		// 如果 以 *** 作数结尾，将最后一 *** 作数入栈
		if (str.length() > 0) {
			try {
				float f = Float.parseFloat(str.toString());
				stk.push(f);
			} catch (Exception e) {
				flag = false;
				return -1;
			}
			str.delete(0, str.length());
		}
		//最后个字符为"("
		if(stk2.peek()=='#'){
			flag=false;
			return -1;
		}
		while (stk2.peek() != '#') {
			try {
				float b = Float.parseFloat(stk.pop().toString());
				float a = Float.parseFloat(stk.pop().toString());// 取出 *** 作数栈两数
				char c1 = stk2.pop();// 取出 *** 作符
				switch (c1) {
				case '+':
					stk.push(a + b);
					break;
				case '-':
					stk.push(a - b);
					break;
				case '*':
					stk.push(a * b);
					break;
				case '/':
					// if (b == 0) {
					// 除数为零
					// } else {
					stk.push(a / b);

					// }
					break;
				default:
					break;
				}
			} catch (Exception e) {
				flag = false;
				return -1;
			}
		}
		try {
			return Float.parseFloat(stk.pop().toString());
		} catch (Exception e) {
			flag = false;
			return -1;
		}
	}

判断运算符优先级

// 判断优先级
	public static int judge(char c) {
		int n = 0;
		switch (c) {
		case '(':
			n = 3;
			break;
		case '+':
		case '-':
			n = 1;
			break;
		case '*':
		case '/':
			n = 2;
			break;
		case ')':
			n = 0;
			break;
		default:
		}
		return n;
	}