java中应用Stack进行算术运算的操作

java.util.stack，继承自vector

filo, 适合带有小括号的算术运算

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);   
  }   
   
}  

补充：java stack实现的中缀简单四则运算表达式计算

我就废话不多说了，大家还是直接看代码吧~

public abstract class stack<t> {
  public abstract boolean isempty();
  public abstract boolean isfull();
  public abstract t top();
  public abstract boolean push(t x);
  public abstract t pop();
  public abstract void clear();
}

public class seqstack<t> extends stack<t> {
  private object[] elementdata;
  private int maxtop;
  private int top;
  public seqstack(int size) {
    this.maxtop = size - 1;
    elementdata = new object[size];
    top = -1;
  }
  @override
  public boolean isempty() {
    return top == -1;
  }
  @override
  public boolean isfull() {
    return top == maxtop - 1;
  }
  @suppresswarnings("unchecked")
  @override
  public t top() {
    if (top == -1) {
      system.out.println("empty");
      return null;
    }
    return (t) elementdata[top];
  }
  @override
  public boolean push(t x) {
    if (top == maxtop) {
      system.err.println("full");
      return false;
    }
    elementdata[++top] = x;
    return true;
  }
  @suppresswarnings("unchecked")
  @override
  public t pop() {
    if (top == -1) {
      system.err.println("empty");
      return null;
    }
    
    t result = (t)elementdata[top];
    elementdata[top] = null; //gc
    top--;
    return result;
  }
  @override
  public void clear() {
    
    //let gc do its work
    for(int i = 0; i < top+1; i++) {
      
      elementdata[i] = null;
    }
    
    top = -1;
  }
}

public class stackcalc {
  private seqstack<integer> stack;
  public stackcalc(int maxsize) {
    stack = new seqstack<integer>(maxsize);
  }
  private void pushoperand(integer number) {
    stack.push(number);
  }
  private number dooperate(char oper) {
    integer right = stack.pop();
    integer left = stack.pop();
    integer result = null;
    if (left != null && right != null) {
      switch (oper) {
      case '+':
        result = left.intvalue() + right.intvalue();
        break;
      case '-':
        result = left.intvalue() - right.intvalue();
        break;
      case '*':
        result = left.intvalue() * right.intvalue();
        break;
      case '/':
        if (right.intvalue() == 0) {
          system.err.println("divide by 0");
        }
        result = left.intvalue() / right.intvalue();
        break;
      default:
        break;
      }
    }
    stack.push(result);
    return result;
  }
  private int icp(char c) {
    switch (c) {
    case '#':
      return 0;
    case '(':
      return 7;
    case '*':
      return 4;
    case '/':
      return 4;
    case '+':
      return 2;
    case '-':
      return 2;
    case ')':
      return 1;
    default:
      return -1;
    }
  }
  private int isp(int c) {
    switch (c) {
    case '#':
      return 0;
    case '(':
      return 1;
    case '*':
      return 5;
    case '/':
      return 5;
    case '+':
      return 3;
    case '-':
      return 3;
    case ')':
      return 7;
    default:
      return -1;
    }
  }
  public string transfer(string expression) {
    stringbuilder sb = new stringbuilder();
    seqstack<character> stack = new seqstack<character>(expression.length());
    stack.push('#');
    for (int i = 0; i < expression.length(); i++) {
      character c = expression.charat(i);
      if ('0' <= c && c <= '9' || 'a' <= c && c <= 'z' ||
          'a' <= c && c <= 'z') { // digit character
        sb.append(c);
      } else { // 操作符
        if (icp(c) > isp(stack.top())) { // 进栈
          stack.push(c);
        } else { // 出栈
          if (c == ')') {
            char ch = stack.pop();
            while (ch != '(') {
              sb.append(ch);
              ch = stack.pop();
            }
          } else {
            char ch = stack.pop();
            while (icp(c) <= isp(ch)) {
              sb.append(ch);
              ch = stack.pop();
            }
            stack.push(ch);
            stack.push(c);
          }
        }
      }
    } // end of for
    char ch = stack.pop();
    while (ch != '#') {
      
      sb.append(ch);
      ch = stack.pop();
    }
    stack.clear();    
    return sb.tostring();
  }
  public integer calc(string expression) {
    expression = transfer(expression);
    for (int i = 0; i < expression.length(); i++) {
      char c = expression.charat(i);
      switch (c) {
      case '+':
      case '-':
      case '*':
      case '/':
        dooperate(c);
        break;
      default:
        pushoperand(new integer(c + ""));
        break;
      }
    }
    return stack.pop();
  }
  /**
   * @param args
   */
  public static void main(string[] args) {
    stackcalc calc = new stackcalc(10);
    system.out.println(calc.calc("6/(4-2)+3*2"));
  }
}

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。如有错误或未考虑完全的地方，望不吝赐教。