#java实现简单计算器功能

仅限于+ - * /运算符

代码如下

package com.atguigu.stack;
public class Calculator {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 根据前面的思路，完成表达式的运算
		String expression = "70+2*6-4";
		// 创建两个栈，数栈和符号栈
		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语句循环的扫描expreion
		while (true) {
			// 依次得到expression的每一个字符
			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())) {
						// 从数栈pop两个数运算
						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 {// 如果是数字，直接入栈
					// numStack.push(ch - 48);//'1'>1
					// 当处理多位数时，不能发现一个数就立即入栈，可能是多位数
					// 在处理数时，需要向expression的表达式的index后zai看一位，如果是数就继续扫描，，如果是符号才入栈
					// 我们需要定义一个变量，用于拼接

				// 处理多位数
				keepNum += ch;
				// 如果ch是expression的最后一位，直接入栈
				if (index == expression.length() - 1) {
					numStack.push(Integer.parseInt(keepNum));
				} else {

					// 判断下一个字符是不是数字，如果是，就继续扫描，如果是运算符就入栈
					// 只是看后面的一位，值不变
					if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
						// 如果后一位是运算符，则入栈
						numStack.push(Integer.parseInt(keepNum));
						// 重要的！！！！，keepNum清空
						keepNum = "";
					}
				}

			}
			// 让index+1，并判断是否扫描到expression最后
			index++;
			if (index >= expression.length()) {
				break;
			}
		}
		// 当表达式扫描完毕时，就顺序的从 数栈和符号栈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);
		}
		// 数栈最后pop出的就是最后结果
		int res2 = numStack.pop();
		System.out.printf("表达式%s = %d", expression, res2);
	}
}

//先创建一个栈，直接使用前面创建好的
//定义一个ArrayStack2类，表示栈结构，需要扩展功能，
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;
	}
	//出栈
	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\n",i,stack[i]);
		}
	}
	
	//返回运算符的优先级，优先级由程序员来确定，优先级使用数字表示
	//数字越大，则优先级越高
	public int priority(int oper){
		if(oper=='*'||oper =='/'){
			return 1;
		}else if(oper =='+'||oper =='-'){
			return 2;
		}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;//res用于存放计算的结果
		switch (oper) {
		case '+':
			res = num1+num2;
			break;
		case '-':
			res = num2-num1;//注意顺序
			break;
		case '*':
			res = num1*num2;
			break;
		case '/':
			res = num2/+num1;
			break;
		default:
			break;
		}
		return res;
	}
}

运行结果：表达式70+2*6-4 = 78

思路：
1.完成栈表的建立以及栈的基本操作
2.创建两个栈，分别为符号栈和数栈
3.完成如下方法：（1）判断是不是一个运算符（2）比较运算符的优先级，数字越大，优先级越高（3）返回栈顶的值，不是出栈操作（4）计算方法
4.定义辅助变量index由于扫描表达式
5.按顺序扫描，判断是否为运算符，若为运算符，就比较运算符的优先级，如果当前的操作符优先级小于或等于栈中的操作符， 从符号栈中pop出一个符号，进行运算，将得到结果入数栈，然后将当前的操作符入符号栈；如果当前的操作符优先级大于栈中的操作符,直接入栈；如如果是数字，直接进栈（多位数字的拼接），当表达式扫描到最后，数栈留下的数就是最后结果