java 用栈实现加减乘除计算器（整理笔记）

用数组模拟栈，定义两个栈，一个数栈NumStack用于压入数据，一个符号栈用于压入符号

首先创建基础栈类

定义栈最大max容量，定义数组存数据，定义top指针表示栈顶元素

构造器就用于初始化栈容量，依次定义栈满栈空判断函数，入栈出栈操作注意top指针的移动

//创建栈类，
class ArrayStack2{
	private int maxSize; //栈的大小
	private int[] stack;  //数组模拟栈，数据放入数组
	private int top=-1;  //top表示栈顶，初始化-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()) {
			throw new RuntimeException("栈空");
		}
		for(int i=top;i>=0;i--) {
			System.out.printf("stack[%d]=%d\n",i,stack[i]);
		}
	}
	
	//返回运算符优先级，优先级使用数字表示
	public int priority(int oper) {
		if(oper=='*' || oper=='/') {
			return 1;
		}else if(oper=='+' || oper=='-') {
			return 0;
		}else {
			return -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;
	}
	
	
}

主函数定义变量，初始化两个栈，keepNum字符串用于判断拼接多位数

//创建两个栈，数栈，一个符号栈
		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循环扫描字符运算串

**重点 ch=expression.substring(index, index+1).charAt(0);依次获取每个字符

先判断是运算符还是数字，运算符比较符号栈中的运算符，进行计算或y压入

数字需要index后多看一位，若还是数字则拼接。

//循环扫描expression
while(true) {
    //依次得到每个字符
    ch=expression.substring(index, index+1).charAt(0);
    //判断ch是什么
    if(operStack.isOper(ch)) {  //运算符
        if(!operStack.isEmpty()) {
            //不为空，如果符号栈由操作符，就进行比较，如果当前操作符优先级小于等于栈中的操作符，就
            //从符号栈pop出一个符号，进行运算，将结果压入数栈，再将当前操作符压入符号栈
            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);
        }
    }else {  //如果是数，则直接进入数栈
        //1.处理多位数，不能扫到一个数字就入栈，可能是多位数
        //2.处理数，需要向expression的表达式的index后再看一位，进行判断
        //3.需要定义字符串变量，破解
        keepNum +=ch;

        if(index==expression.length()-1) {   //若ch是最后一位，直接入栈
            numStack.push(Integer.parseInt(keepNum));
        }else {
            //判断下一个字符是不是数字，如果是就进行扫描，，是字符就压入栈，这里只是查看，index不移动
            if(operStack.isOper(expression.substring(index+1, index+2).charAt(0))) {
                //如果是运算符了，就keepNum压入数栈为字符，需要转换，"123",integer.parseInt(）方法
                numStack.push(Integer.parseInt(keepNum));
                keepNum="";  //再重置拼接字符工具
            }
        }
    }
    //让index+1 ，并判断石佛扫描到expression的最后
    index++;
    if(index>=expression.length()) {
        break;
    }
}

最后扫描完毕，则顺序的从数栈和符号栈中pop出相应的数和符号，并运算。

//当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运算
		while(true) {
			//如果符号栈为空，则计算到最后的结果，数栈最后一个数，就是运算结果
			if(operStack.isEmpty()) {
				break;
			}
			num1=numStack.pop();
			num2=numStack.pop();
			oper=operStack.pop();
			res=numStack.cal(num1, num2, oper);
			numStack.push(res);  //入栈
		}
		//
		int res2=numStack.pop();  //弹出最后一个数据，就是结果
		System.out.println("表达式"+expression+"="+res2);
	}