Stack栈之四则运算（取需）

package Lanwei_20150615Stack_Operate;

import java.util.Stack;

/**
 * 应用栈，进行四则运算的类 用两个栈来实现算符优先，一个栈用来保留须要盘算的数据numStack,一个用来保留盘算优先符priStack
 * 
 * 根本算法实现思路为：用当前获得的运算符与priStack栈顶运算符比拟优先级：若高于，则由于会先运算，放入栈顶；
 * 若等于，由于涌现在后面，所以会后盘算，所以栈顶元素出栈，取出操作数运算； 若小于，则同理，取出栈顶元素运算，将成果入操作数栈。各个优先级"(" > "*"
 * = "/" > "+" = "-" > ")"
 * 
 */
public class Operate {
	private Stack<Character> priStack = new Stack<Character>();// 操作符栈
	private Stack<Integer> numStack = new Stack<Integer>();;// 操作数栈

	/**
	 * 传入须要解析的字符串，返回盘算成果(此处由于时光问题，省略合法性验证)
	 * 
	 * @param str
	 *            须要进行技巧的表达式
	 * @return 盘算成果
	 */
	public int caculate(String str) {
		// 1.断定string当中有不过法字符
		String temp;// 用来临时寄存读取的字符
		// 2.重复开端解析字符串，当字符串解析完，且符号栈为空时，则盘算完成
		StringBuffer tempNum = new StringBuffer();// 用来临时寄存数字字符串(当为多位数时)
		StringBuffer string = new StringBuffer().append(str);// 用来保留，进步效力

		while (string.length() != 0) {
			temp = string.substring(0, 1);
			string.delete(0, 1);
			// 断定temp，当temp为操作符时
			if (!isNum(temp)) {
				// 1.此时的tempNum内即为须要操作的数，取出数，压栈，并且清空tempNum
				if (!"".equals(tempNum.toString())) {
					// 当表达式的第一个符号为括号
					int num = Integer.parseInt(tempNum.toString());
					numStack.push(num);
					tempNum.delete(0, tempNum.length());
				}
				// 用当前获得的运算符与栈顶运算符比拟优先级：若高于，则由于会先运算，放入栈顶；若等于，由于涌现在后面，所以会后盘算，所以栈顶元素出栈，取出操作数运算；
				// 若小于，则同理，取出栈顶元素运算，将成果入操作数栈。

				// 断定当前运算符与栈顶元素优先级，取出元素，进行盘算(由于优先级可能小于栈顶元素，还小于第二个元素等等，须要用重复断定)
				while (!compare(temp.charAt(0)) && (!priStack.empty())) {
					int a = (int) numStack.pop();// 第二个运算数
					int b = (int) numStack.pop();// 第一个运算数
					char ope = priStack.pop();
					int result = 0;// 运算成果
					switch (ope) {
					// 如果是加号或减号，则
					case "+":
						result = b + a;
						// 将操作成果放入操作数栈
						numStack.push(result);
						break;
					case "-":
						result = b - a;
						// 将操作成果放入操作数栈
						numStack.push(result);
						break;
					case "*":
						result = b * a;
						// 将操作成果放入操作数栈
						numStack.push(result);
						break;
					case "/":
						result = b / a;// 将操作成果放入操作数栈
						numStack.push(result);
						break;
					}

				}
				// 断定当前运算符与栈顶元素优先级， 如果高，或低于平，盘算完后，将当前操作符号，放入操作符栈
				if (temp.charAt(0) != "#") {
					priStack.push(new Character(temp.charAt(0)));
					if (temp.charAt(0) == ")") {// 当栈顶为"("，而当前元素为")"时，则是括号内以算完，去掉括号
						priStack.pop();
						priStack.pop();
					}
				}
			} else
				// 当为非操作符时（数字）
				tempNum = tempNum.append(temp);// 将读到的这一名数接到以读出的数后(当不是个位数的时候)
		}
		return numStack.pop();
	}

	/**
	 * 断定传入的字符是否是0-9的数字
	 * 
	 * @param str
	 *            传入的字符串
	 * @return
	 */
	private boolean isNum(String temp) {
		return temp.matches("[0-9]");
	}

	/**
	 * 比拟当前操作符与栈顶元素操作符优先级，如果比栈顶元素优先级高，则返回true，否则返回false
	 * 
	 * @param str
	 *            须要进行比拟的字符
	 * @return 比拟成果 true代表比栈顶元素优先级高，false代表比栈顶元素优先级低
	 */
	private boolean compare(char str) {
		if (priStack.empty()) {
			// 当为空时，明显 当前优先级最低，返回高
			return true;
		}
		char last = (char) priStack.lastElement();
		// 如果栈顶为"("明显，优先级最低，")"不可能为栈顶。
		if (last == "(") {
			return true;
		}
		switch (str) {
		case "#":
			return false;// 停止符
		case "(":
			// "("优先级最高,明显返回true
			return true;
		case ")":
			// ")"优先级最低，
			return false;
		case "*": {
			// "*/"优先级只比"+-"高
			if (last == "+" || last == "-")
				return true;
			else
				return false;
		}
		case "/": {
			if (last == "+" || last == "-")
				return true;
			else
				return false;
		}
		// "+-"为最低，一直返回false
		case "+":
			return false;
		case "-":
			return false;
		}
		return true;
	}

	public static void main(String args[]) {
		Operate operate = new Operate();
		int t = operate.caculate("(3+4*(4*10-10/2)#");
		System.out.println(t);
	}

}package Lanwei_20150615Stack_Operate;

import jav