计算表达式的值，最简单版本

package com.ysb;

import java.util.Stack;

/**
 * @param args
 *            输入：一串字符串 输出:运算结果，不考虑非法输入，暂时不考虑括号 算法流程： 1.读取1个操作数 压入操作数栈 operand1
 *            2.读取1个操作符 压入操作符栈 3.读取下1个操作数 压入操作数栈 operand2 4.读取下1个操作符 operator2
 *            5.操作符栈出栈得到operator1 判断operator2和operato1的优先级 a. operator2优先级 >
 *            operator1优先级
 *            读取下1个操作数operand3，operand2,operator2出栈，将operand3和operand2使用operator2计算得到结果压入操作数栈
 *            回到2循环 b. operator2优先级 <= operato1优先级 操作数栈出栈2个 使用Operator1计算 压入栈
 *            回到1
 * 
 * 5+3*3*3
 */
public class Test1 {
	// 操作数栈
	Stack<Float> operandStack = new Stack<Float>();

	// 操作符栈
	Stack<String> operatorStack = new Stack<String>();

	public static void main(String[] args) {

		new Test1().run();
	}

	public void run() {
		StringBuilder inputString = new StringBuilder("1*2+3-4*5/2");
		
		int index = 0;
		float operandInStack = 0;
		float operandInString = 0;
		String operatorInStack = "";
		String operatorInString = "";
		operandInStack = getOperand(inputString, index++);
		operandStack.push(operandInStack);
		operatorInStack = getOperator(inputString, index++);
		operatorStack .push(operatorInStack);
		
		while (true) {
			operandInString = getOperand(inputString, index++);
			if(inputString.length() == 0) {
				operandStack.push(operandInString);
				while(true) {
				
				float operandStack2 = operandStack.pop();
				operandInStack = operandStack.pop();
				
				operatorInStack = operatorStack.pop();
				
				float result =  compute(operandInStack, operandStack2,
						operatorInStack);
				operandStack.push(result);
				if(operandStack.size() == 1)
					break;
				}
				break;
			}
			operatorInString = getOperator(inputString, index++);
			operatorInStack = operatorStack.pop();
			
			
			if (getOperatorLevel(operatorInString) > getOperatorLevel(operatorInStack)) {
				operandStack.push(operandInString);
				operatorStack.push(operatorInStack);
				operatorStack.push(operatorInString);
				continue;
			} else {
				operandInStack = operandStack.pop();
				float result = compute(operandInStack, operandInString,
						operatorInStack);
				operandStack.push(result);
				operatorStack.push(operatorInString);
				if (inputString.length() == 0)
					break;
				else
					continue;              
			}
		}
		System.out.println(operandStack.pop());
	}
/*
 *  操作数栈   操作符栈       1+2*3*4*5+6
 *    1     
 *              
 *                              2 +         
 *    6        +
 */
	/**
	 * 从指定的index处获取1个操作数
	 * 
	 * @param inputString
	 * @return 操作数
	 */
	public float getOperand(StringBuilder inputString, int index) {
		float f = Float.parseFloat(inputString.substring(0,1));
		inputString = inputString.delete(0,1);
		return   f;
	}

	/**
	 * 从指定的index处获取1个操作符
	 * 
	 * @return 操作符
	 */
	public String getOperator(StringBuilder inputString, int index) {
		String operator = inputString.substring(0,1);
		inputString = inputString.delete(0,1);
		return operator;
	}

	/**
	 * @param operator
	 *            操作符
	 * @return 操作符的优先级
	 */
	public int getOperatorLevel(String operator) {
		if (operator.equals("+") || operator.equals("-"))
			return 1;
		else if (operator.equals("*") || operator.equals("/"))
			return 2;
		else
			return 3;

	}

	public float compute(float operand1, float operand2, String operator) {
		if (operator.equals("+"))
			return operand1 + operand2;
		else if (operator.equals("-"))
			return operand1 - operand2;
		else if (operator.equals("*"))
			return operand1 * operand2;
		else if (operator.equals("/"))
			return operand1 / operand2;
		return 0;
	}
}

 运行结果

-5.0