JAVA 实现高级计算器程序

用JAVA编写了一个高级计算器程序，可以实现带括号的四则运算，如同数据结构书上所讲，可以利用栈将中缀表达式转换为后缀表达式，再利用栈计算后缀表达式。中缀表达式符合人的思维习惯，但计算机却容易理解后缀表达式。

话不多说，直接上代码：

package indi.list;
import java.util.*;

public class Calculator {
	private static final int MAXCAPACITY = 500;
	private String expression;
	
	public Calculator(String expression) {
		if(expression.length() > MAXCAPACITY)
			System.out.println("字符串长度超出最大值");
		else
			this.expression=expression;
	}
	
	public int getPriority(String str) {
		int pri=-1;
		
		if(str.equals("("))
			pri=0;
		else if(str.equals("+") || str.equals("-"))
			pri=1;
		else if(str.equals("*") || str.equals("/"))
			pri=2;
		
		return pri;		
	}
	
	public String[] split() {
		ArrayList<String> strList=new ArrayList<String>();
		int splitIndex=0;
		
		for(int i=0;i<expression.length();i++) {
			if(expression.charAt(i)=='+' || expression.charAt(i)=='-' || expression.charAt(i)=='*' || expression.charAt(i)=='/' || expression.charAt(i)=='(' || expression.charAt(i)==')'){				
				if(splitIndex == i) { //处理连续多个操作符
					if(expression.charAt(i)=='-') {     //处理操作符"( + - * /"符号后面遇到"-"情况时，将后面的数字当做负数处理
						splitIndex=i;
						continue;
					}
					else
						strList.add(expression.substring(splitIndex, i+1));
				}
				else {
					strList.add(expression.substring(splitIndex, i));
					strList.add(expression.substring(i, i+1));
				}
				splitIndex=i+1;
			}
			if((i==expression.length()-1) && (splitIndex<=i))
				strList.add(expression.substring(splitIndex));
		}
		
		return strList.toArray(new String[0]);
	}
	
	public String[] getSuffixExpression(String[] expression) {
		Stack<String> strStack=new Stack<String>();
		ArrayList<String> strList=new ArrayList<String>();
		
		for(int i=0;i<expression.length;i++) {
			if(expression[i].equals("("))  //遇到'('时入栈
				strStack.push(expression[i]);
			else if(expression[i].equals("+") || expression[i].equals("-") ||expression[i].equals("*") ||expression[i].equals("/")) {
				if(strStack.isEmpty())     //栈空时操作符入栈
					strStack.push(expression[i]);
				else {                     //否则比较栈顶操作符优先级
					while((!strStack.isEmpty()) && (getPriority(strStack.peek())>=getPriority(expression[i]))) {
						strList.add(strStack.pop());
					}
					strStack.push(expression[i]);
				}				
			}
			else if(expression[i].equals(")")) {//遇到')'时出栈直至'('
				while(!strStack.peek().equals("(")){
					strList.add(strStack.pop());
				}
				strStack.pop(); //抛出'('
			}
			else
				strList.add(expression[i]);
		}
		while(!strStack.isEmpty())
			strList.add(strStack.pop());
		
		return strList.toArray(new String[0]);
	}
	
	public double getResult(String[] expression) {
		Stack<Double> strStack=new Stack<Double>();
		double num1,num2;
		double result=0;
		
		for(int i=0;i<expression.length;i++) {
			if(expression[i].equals("+") || expression[i].equals("-") ||expression[i].equals("*") ||expression[i].equals("/")) {
				String str=expression[i];
				switch(str) {
					case "+":{num1=strStack.pop();num2=strStack.pop();result=num2+num1;strStack.push(result);break;}
					case "-":{num1=strStack.pop();num2=strStack.pop();result=num2-num1;strStack.push(result);break;}
					case "*":{num1=strStack.pop();num2=strStack.pop();result=num2*num1;strStack.push(result);break;}
					case "/":{num1=strStack.pop();num2=strStack.pop();result=num2/num1;strStack.push(result);break;}
				}
			}
			else
				strStack.push(Double.valueOf(expression[i]));
		}
		
		result=0;
		while(!strStack.isEmpty()) {
			result+=strStack.pop();
		}
		
		return result;
	}
	
	public double getResult() {
		return getResult(getSuffixExpression(split()));
	}
}

上述代码为一个计算器类，包含了6个方法：

（1）public Calculator(String expression)：构造函数

（2）public int getPriority(String str)：获得运算符优先级

（3）public String[] split()：字符串分割

（4）public String[] getSuffixExpression(String[] expression)：获得后缀表达式

（5）public double getResult(String[] expression)：获得运算结果

（6）public double getResult()：获得运算结果

由于JAVA自带的分割函数实现的功能有限，所以这里自己实现了一个字符串分割函数，返回字符串数组，并且可以识别负数的情景。

主类中测试代码为：

package indi.list;

public class Main {

	public static void main(String[] args) {
		Calculator exp1=new Calculator("-6/(-5.8-3)+0.3*(8-9)/6");
		
		String[] strSplit=exp1.split();
		String[] strSuffixExpression=exp1.getSuffixExpression(strSplit);
		double result=exp1.getResult(strSuffixExpression);
		
		System.out.println("---------原字符串是---------");
		System.out.println("-6/(-5.8-3)+0.3*(8-9)/6");
		System.out.println("-------分割后的字符串是-------");
		for(int i=0;i<strSplit.length;i++)
			System.out.print("["+strSplit[i]+"]"+"\t");
		System.out.println("\n");
		System.out.println("-------后缀形式的字符串是-------");
		for(int i=0;i<strSuffixExpression.length;i++)
			System.out.print("["+strSuffixExpression[i]+"]"+"\t");
		System.out.println("\n");
		System.out.println("---------最后计算结果是---------");
		System.out.println(result);
		System.out.println("-------计算机计算结果是-------");
		result=-6/(-5.8-3)+0.3*(8-9)/6;
		System.out.println(result);
	}

}

输出结果为：

---------原字符串是---------
-6/(-5.8-3)+0.3*(8-9)/6
-------分割后的字符串是-------
[-6]	[/]	[(]	[-5.8]	[-]	[3]	[)]	[+]	[0.3]	[*]	[(]	[8]	[-]	[9]	[)]	[/]	[6]	

-------后缀形式的字符串是-------
[-6]	[-5.8]	[3]	[-]	[/]	[0.3]	[8]	[9]	[-]	[*]	[6]	[/]	[+]	

---------最后计算结果是---------
0.6318181818181817
-------计算机计算结果是-------
0.6318181818181817

今天的文章JAVA 实现高级计算器程序分享到此就结束了，感谢您的阅读。