栈模拟计算器-中缀表达式

package com.wang;

public class Math {

	public static void main(String[] args) {
		//待计算表达式
		String experssion="73+2*6-2";
		//创建一个符号栈和一个数栈
		ArrStack numStack = new ArrStack(10);
		ArrStack operStack = new ArrStack(10);
		//用于扫描
		int index=0;
		int num1=0;
		int num2 = 0;
		int oper=0;
		//用于链接多位数
		String keepnum="";
		//结果
		int results=0;
		//将每次扫描的到第一位数保存到ch
		char ch=' ';
		while (true) {
			//调用字符串的substring方法依次取出表达式的第一个字符
			ch=experssion.substring(index,index+1).charAt(0);
			//判断该字符是什么并进行相应的处理
			
			//字符
			if (operStack.isoper(ch)) {
				//判断字符栈是否空
				
				//不为空
				if (!operStack.isEmpty()) {
					//进行优先级比较
					if (operStack.priority(ch)<=operStack.priority(operStack.peek())) {
						num1=numStack.pop();
						num2=numStack.pop();
						oper=operStack.pop();
						results=numStack.cal(num1, num2, oper);
						//将运算结果加入数栈
						numStack.push(results);
						//将当前操作符加入符号栈
						operStack.push(ch);
					}else {
						operStack.push(ch);
					}
				}else {
					//空栈直接加入
					operStack.push(ch);
				}
			}else {
				//如果是数字,直接入数字栈
				//numStack.push(Integer.parseInt(ch));
				
				
				//处理多位数
				keepnum+=ch;
				//如果ch已经到了最后一位,直接加入
				if (index==experssion.length()-1) {
					numStack.push(Integer.parseInt(keepnum));
				}else {
					//判断下一位是否为数字，如果是则继续扫描，如果是运算符则入栈
					if (operStack.isoper(experssion.substring(index+1,index+2).charAt(0))) {
						numStack.push(Integer.parseInt(keepnum));
						//入栈后将其清空，以备下次添加
						keepnum="";
					}
				}
			}
			index++;
			if (index>=experssion.length()) {
				break;
			}
		}
		while(true) {
			//如果符号栈为空，就说明计算到了最后的结果
			if (operStack.isEmpty()) {
				break;
			}
			num1=numStack.pop();
			num2=numStack.pop();
			oper=operStack.pop();
			results=numStack.cal(num1, num2, oper);
			numStack.push(results);
		}
		//循环结束后数栈中只剩一个数字，即最后结果
		System.out.println(experssion+"="+numStack.pop());
	}

}
class ArrStack {
	private int maxsize;
	//存放数据
	private int[] arr;
	//栈顶初始化-1
	private int top=-1;
	
	
	public ArrStack(int maxsize) {
		super();
		this.maxsize = maxsize;
		arr = new int[maxsize];
	}
	
	//栈满
	public boolean isFull() {
		return top==maxsize-1;
	}
	
	//栈空
	public boolean isEmpty() {
		return top==-1;
	}
	
	//入栈
	public void push(int value) {
		if (isFull()) {
			System.out.println("满");
			return;
		}
		top++;
		arr[top]=value;
	}
	
	//出栈
	public int pop() {
		if (isEmpty()) {
			throw new RuntimeException("空");
		}
		int value=arr[top];
		top--;
		return value;
	}
	
	//查看栈顶元素
	public int peek() {
		return arr[top];
	}
	
	//遍历
	public void list() {
		if (isEmpty()) {
			return;
		}
		for(int i=top;i>=0;i--) {
			System.out.printf("arr[%d]=%d\n",i,arr[i]);
		}
	}
	
	//确定运算符的优先级
	public int priority(int oper) {
		if (oper=='*'||oper == '/') {
			return 1;
		}else if (oper == '+' || oper == '-') {
			return 0;
		}else {
			throw new RuntimeException("不支持");
		}
	}
	
	//判断是不是一个运算符
	public boolean isoper(char val) {
		return val =='+' || val == '-'||val=='*'||val == '/';
	}
	
	//计算方法
	public int cal(int num1,int num2,int oper) {
		int results=0;
		switch(oper) {
		case '+':
			results=num1+num2;
			break;
		case '-':
			results=num2-num1;
			break;
		case '*':
			results=num2*num1;
			break;
		case '/':
			results=num2/num1;
			break;
		}
		return results;
	}
}