栈实现计算器（简单四则运算）

主要是通过定义一个数栈和一个符号栈，并根据给出的计算式进行拆分，循环判断是数字还是符号，考虑数字的连续性和符号计算的优先级，具体实现如下：

package com.pangzi.stucture;

public class calculator {

public static void main(String[] args) {
String expression = "50+9*9-7";//定义一个需要被扫描的表达式
//创建两个栈，一个数栈，一个符号栈
ArrayStack2 numStack = new ArrayStack2(10);
ArrayStack2 operStack = new ArrayStack2(10);
//定义需要的变量
int index = 0;//定义一个指向数字和运算符的索引,扫描栈中的内容
int num1 = 0;//定义第一个数字
int num2 = 0;//定义第二个数字
int oper = 0;//定义操作符
int res = 0;//定义运算结果
char ch = ' ';//将每次扫描得到的char保存至ch里面
String keepNum = "";//用于拼接多位数
//开始扫描表达式
while(true){
//依次得到expression中的每一个字符
ch = expression.substring(index, index+1).charAt(0);//用substr获取长度为1的一个个字符串，然后通过charat转换为字符。
//判断字符是数字还是运算符,然后进行处理
if(operStack.isOper(ch)){//如果ch是一个符号
//判断符号栈是否为空
if(!operStack.isEmpty()){
//如果符号栈不为空，用ch和符号栈存在的运算符进行比较，如果ch的优先级小于等于栈中符号的优先级
//就从数栈中弹出两个数字，进行运算并将得到的结果放入数栈，然后将ch入符号栈
if(operStack.priority(ch) <= operStack.priority(operStack.peek())){
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1, num2, oper);
numStack.push(res);
operStack.push(ch);
}else{
//如果当前操作符的优先级大于符号栈中的优先级，直接入符号栈
operStack.push(ch);
}
}else{
//如果符号栈为空，进行入栈操作
operStack.push(ch);//将ch入符号栈
}
}else{//如果ch是数据的话,则直接入数栈
//numStack.push(ch - 48);//根据ascii表换算
//当处理多位数时，不能扫描到数字时就立即入栈，因为有可能是多位数
//在处理时，应该在expression的表达式后面在扫描一位，如果是数继续扫描，如果是符合则停止。
//定义一个字符串变量用于拼接数字,keepNum

keepNum += ch;

//判断ch是不是expression表达式的最后一位，如果是最后一位则直接入栈即可
if(index == expression.length() - 1){
numStack.push(Integer.parseInt(keepNum));//将keepNum转换为int,并入栈
}else{

//判断keepNum的后面一位是不是数字,如果是数字就继续扫描，如果不是则不扫描进行入栈
if(operStack.isOper(expression.substring(index+1, index+2).charAt(0))){
//如果后一位是运算符，则入栈
numStack.push(Integer.parseInt(keepNum));//将keepNum转换为int,并入栈
//清空keepNum
keepNum = "";
}
}

}
//让index+1，看是否扫描到最后一个字符
index++;
if(index >= expression.length()){
break;//如果扫描到了最后就跳出循环
}
}
//当expression扫描完毕后，就依次从数栈和符号栈中弹出进行运算。
while(true){
//如果符号栈为空，则任务已经计算到最后的结果了，数栈中只有一个数字，就是结果
if(operStack.isEmpty()){
break;
}
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1, num2, oper);
numStack.push(res);//入栈
}
System.out.printf("表达式%s = %d",expression,numStack.pop());//将最后的结果打印出来
}
}

//定义一个表示栈的类
class ArrayStack2{
private int maxSize;//定义栈的容量
private int[] stack;//定义存储栈数据的数组
private int top = -1;//定义栈顶,初始为-1

//定义构造函数
public ArrayStack2(int maxSize){
this.maxSize = maxSize;
stack = new int[this.maxSize];//初始化数组
}

//获得栈顶的值
public int peek(){
return stack[top];
}

//判断栈是否满了
public boolean isFull(){
return top == maxSize - 1;//如果栈顶等于容量减一的时候,栈就满了
}

//判断栈是否空
public boolean isEmpty(){
return top == -1;
}

//入栈 push
public void push(int value){
//先判断栈是否满了,满了无法入栈
if(isFull()){
System.out.println("栈已满，无法入栈");
return;
}
top++;
stack[top] = value;//将新入栈的数据放入数组
}

//出栈 pop
public int pop(){
//先判断是否为空栈
if(isEmpty()){
//抛出异常
throw new RuntimeException("栈已空");
}
int value = stack[top];//获取弹栈的值
top--;
return value;//返回弹栈的值
}

//显示栈的情况，遍历时需要从栈顶往下走
public void list(){
if(isEmpty()){ //判空
System.out.println("栈空，无数据");
return;
}
for(int i = top;i>=0;i--){
System.out.printf("stack[%d]=%d ",i,stack[i]);
}
}

//返回运算符的优先级，优先级人为来确定的，优先级用数字表示，数字越大优先级越高
public int priority(int oper){
if(oper == '*' || oper == '/'){
return 1;//乘除的优先级为1
}else if(oper == '+' || oper == '-'){
return 0;//加减的优先级为1
}else{
return -1;//有问题返回-1
}

}

//判断是否是一个运算符
public boolean isOper(char val){
return val =='+' || val == '-' || val == '*' || val == '/';
}

//计算方法
public int cal(int num1,int num2,int oper){
int res = 0;//存放计算的结果
switch(oper){
case '+':
res = num1 + num2;
break;
case '-':
res = num2 - num1;//注意顺序，由栈中后弹出的值减去先弹出的
break;
case '*':
res = num1 * num2;
break;
case '/':
res = num2 / num1;//注意顺序，由栈中后弹出的值除先弹出的
break;
}
return res;
}
}