1.中缀表达式求值实现类

package edu.tcu.soft;

import java.util.Stack;

/**
 * 功能:中缀表达式直接求值
 */
public class NifixExpre {

	// 定义操作数栈和操作符栈
	private Stack<Integer> operateNum = new Stack<Integer>();
	private Stack<Character> operateChara = new Stack<Character>();

	// 表达式处理(表达式：运算符【加、减、乘、除、左括号】 运算对象【正数、负数】)
	int expressionHandler(String expre) {
		char[] ex = expre.toCharArray();
		char item;
		// 顺序获取每一运算对象或者运算符
		for (int i = 0; i < ex.length; i++) {
			item = ex[i];
			// 如果当前字符为(,将运算符压入栈内
			if (item == '(') {
				operateChara.push(item);
			}

			// 如果当前字符为运算符 ) ,将运算符栈的运算符出栈直到遇到第一个(
			if (item == ')') {
				// 将操作符栈里面的元素一直出栈，直到遇到第一个左括号为止
				while (operateChara.peek() != '(') {
					char o = operateChara.pop();// 获取操作符
					Integer second = operateNum.pop();// 获取第二个运算对象
					Integer first = operateNum.pop();// 获取第一个运算对象
					Integer result = getResult(first, second, o);// 获取运算结果
					operateNum.push(result);// 将运算结果入栈
				}
				if (operateChara.peek() == '(') {
					// 将左括号移出栈
					operateChara.pop();
				}
			}

			if (item != '(' && item != ')') {
				// 如果当前字符为运算符，入运算符栈
				if (item == '+' || item == '-' || item == '*' || item == '/'
						|| item == '#') {
					// 如果操作符栈为空，入栈
					if (operateChara.empty()) {
						operateChara.add(item);
					} else {
						// 根据优先权的大小，判断操作符是否能进栈
						if (isPush(item, operateChara.peek())) {
							operateChara.push(item);
						} else {
							char o = operateChara.pop();// 获取操作符
							Integer second = operateNum.pop();// 获取第二个运算对象
							Integer first = operateNum.pop();// 获取第一个运算对象
							Integer result = getResult(first, second, o);// 获取运算结果
							operateChara.push(item); // 将当前的运算符入栈
							operateNum.push(result);// 将运算结果入栈
						}
					}
				}
				// 如果当前字符为运算对象
				else if (0 <= Integer.parseInt(String.valueOf(item))
						&& Integer.parseInt(String.valueOf(item)) <= 9) {
					operateNum.push(Integer.parseInt(String.valueOf(item)));
				}
				/*else if(0 <= Integer.parseInt(String.valueOf(item))
						&& Integer.parseInt(String.valueOf(item)) <= 9){
				Stack<Integer> stack=new Stack<>();
				int amount=0;
				while(0 <= Integer.parseInt(String.valueOf(ex[i]))
						&& Integer.parseInt(String.valueOf(ex[i])) <= 9){
					Integer sin=Integer.parseInt(String.valueOf(ex[i]));
					stack.push(sin);
					i++;
				}
				for(int j=0;j<stack.size();j++){
					amount=(int) (amount+stack.pop()*Math.pow(10, j));
				}
				System.out.println("amount"+amount);
				operateNum.push(amount);*/
			}
		}
		return operateNum.peek();
	}

	// 判断是否要把操作符移入栈内
	private boolean isPush(char item, Character peek) {
		if (getPriority(item) > getPriority(peek))
			return true;
		return false;
	}

	// 获取操作符的优先权值
	private int getPriority(Character peek) {

		if (peek == '#') {
			return 0;
		}
		if (peek == '(') {
			return 1;
		} 
		if (peek == '+' || peek == '-') {
			return 2;
		}
		if (peek == '*' || peek == '/') {
			return 3;
		}
		else {
			return -1;
		}
	}

	// 计算
	private Integer getResult(Integer first, Integer second, char o) {

		switch (o) {
		case '+':
			return first + second;
		case '-':
			return first - second;
		case '*':
			return first * second;
		case '/':
			return first / second;
		default:
			break;
		}
		return null;
	}
}

package edu.tcu.soft;


public class Test {
  public static void main(String[] args) {

    NifixExpre expre=new NifixExpre();
    System.out.println("中缀表达式求值："+expre.expressionHandler("#3*(4+2)/2-5#"));
}
}

这个实现方法还不是很完善，只能进行个位数的加减乘除运算，