Java 计算器

以下是自己用Java写的一个计算器类。
支持科学计数表达式的结果，但不支持在过程中的计算。
支持字符串的数学表达式，包括括号，指数运算，然后最后直接计算。
附件是可以直接运行的jar文件(电脑上需要有JDK环境)

package com.eric.calculator;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

/**
 * 支持科学计数表达式的结果，但不支持在过程中的计算
 * @author Yuanbo Han
 *
 */
public class Calculator {
	
	public static boolean checkBalance(String expression){
		boolean balanced = true;
		Stack<Character> stack = new Stack<Character>();
		for(int i=0;balanced && i<expression.length();i++){
			char ch = expression.charAt(i);
			switch(ch){
			case '(':	case '[':	case '{':
				stack.push(ch);
				break;
			case ')':	case ']':	case '}':
				if(stack.isEmpty()){
					balanced = false;
				}else{
					char pop = stack.pop();
					balanced = isPaired(pop,ch);
				}
				break;
			}
		}
		if(!stack.isEmpty()){
			balanced = false;
		}
		return balanced;
	}
	
	private static boolean isPaired(char left, char right){
		return  (left == '(' && right == ')') ||
				(left == '[' && right == ']') ||
				(left == '{' && right == '}');
	}
	
	/**
	 * 需要处理的数据类型包括：
	 * 	运算数 ^ + - * / ( )
	 * 中缀表达式转变为后缀表达式时，遇到相应的符号所对应的动作：
	 * 	运算数：	添加到输出表达式的末尾
	 *  ^：		压入栈
	 *  +-* /：	从栈中弹出运算符并添加到表达式的末尾，直到栈为空或者栈顶优先级比该新的运算符低。然后将新的运算符压入栈
	 *  ( ：		压入栈
	 *  ) ：		从栈中弹出运算符并添加到表达式的末尾，直到弹出(，丢弃这两个括号	
	 * @param expression
	 * @return 后缀表达式中的操作数以一个固定的符号来分开，如 _
	 */
	public static String convert2Postfix(String expression, String regex){
		Stack<String> stack = new Stack<String>();
		StringBuffer sb = new StringBuffer();
		String[] arr = process(expression);
		for(int i=0;i<arr.length;i++){
			String ch = arr[i];
			if(isDouble(ch)){
				sb.append(ch + regex);
			}else{
				if(ch.equals("^")){
					stack.push(ch);
				} else if(ch.equals("+") || ch.equals("-") || ch.equals("*") || ch.equals("/")){
					while(!stack.isEmpty()){
						String top = stack.peek();
						if(getPrecedence(ch.charAt(0)) <= getPrecedence(top.charAt(0))){
							sb.append(top + regex);
							stack.pop();
						}else{
							break;
						}
					}
					stack.push(ch);
				} else if(ch.equals("(")){
					stack.push(ch);
				} else if(ch.equals(")")){
					String pop = stack.pop();
					while(!pop.equals("(")){
						sb.append(pop + regex);
						pop = stack.pop();
					}
				}
			}
		}
		
		while(!stack.isEmpty()){
			String pop = stack.pop();
			sb.append(pop + regex);
		}
		
		return sb.toString();
	}
	
	/**
	 * 判断是否是一个double型数值
	 * @param input
	 * @return
	 */
	private static boolean isDouble(String input){
		try {
			Double.parseDouble(input);
			return true;
		} catch (NumberFormatException e) {
			return false;
		}
	}
	
	/**
	 * 将expression处理下，以运算符来将expression分隔成数组
	 * @param expression
	 * @param index
	 * @return
	 */
	public static String[] process(String expression){
		List<String> list = new ArrayList<String>();
		char[] arr = expression.toCharArray();
		StringBuffer sb = new StringBuffer();
		for(int i=0;i<arr.length;i++){
			if(arr[i] == '-'){//考虑到-不仅是减号，还有可能是负号
				if(i == 0 || (arr[i-1] == '(' || arr[i-1] == ')' || arr[i-1] == '+' || arr[i-1] == '-' || arr[i-1] == '*' || arr[i-1] == '/')){
					sb.append("-");
				} else{
					if(!sb.toString().trim().equals("")){
						list.add(sb.toString());
					}
					list.add(String.valueOf(arr[i]));
					sb = new StringBuffer();
				}
			} else if(arr[i] != '(' && arr[i] != ')' && arr[i] != '+' && arr[i] != '*' && arr[i] != '/' && arr[i] != '^' ){
				sb.append(arr[i]);
			} else{
				if(!sb.toString().trim().equals("")){
					list.add(sb.toString());
				}
				list.add(String.valueOf(arr[i]));
				sb = new StringBuffer();
			}
		}
		if(!sb.toString().trim().equals("")){//将最后的数据放入到list中
			list.add(sb.toString());
		}
		return list.toArray(new String[list.size()]);
	}
	
	private static int getPrecedence(char ch){
		switch(ch){
		case '(':	case ')':	return 0;
		case '+':	case '-':	return 1;
		case '*':	case '/':	return 2;
		case '^':				return 3;
		default:				return -1;
		}
	}
	
	/**
	 * expression是中缀表达式
	 * @param regex
	 * @param expression
	 * @return
	 */
	public static double calculateExpression(String expression, String regex){
		Stack<Double> stack = new Stack<Double>();
		String[] arr = convert2Postfix(expression,regex).split(regex);
		for(int i=0;i<arr.length;i++){
			String ch = arr[i];
			if(isDouble(ch)){
				stack.push(Double.parseDouble(String.valueOf(ch)));
			}else{
				double two = stack.pop();
				double one = stack.pop();
				char operator = ch.charAt(0);
				double value = calculate(one,two,operator);
				stack.push(value);
			}
		}
		
		return stack.peek();
	}
	
	private static double calculate(double one, double two, char operator){
		switch(operator){
		case '+':
			return one + two;
		case '-':
			return one - two;
		case '*':
			return one * two;
		case '/':
			return one / two;
		case '^':
			return (int)Math.pow(one, two);
		}
		return 0;
	}

	public static void main(String[] args) {
		CalculatorFrame frame = new CalculatorFrame();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setResizable(false);
		frame.setVisible(true);
		
	}
}

	@SuppressWarnings("serial")
	class CalculatorFrame extends JFrame {
		public CalculatorFrame() {
			this.setTitle("计算器");
			CalculatorPanel panel = new CalculatorPanel();
			this.add(panel);
	
			Toolkit kit = Toolkit.getDefaultToolkit();
			Dimension dimension = kit.getScreenSize();
			double x = dimension.getWidth() / 3;
			double y = dimension.getHeight() / 3;
			setLocation((int) x, (int) y);
	
			this.pack();
		}
	
	}

	@SuppressWarnings("serial")
	class CalculatorPanel extends JPanel {
		private JTextField display;
		private JPanel panel;
	
		public CalculatorPanel() {
			this.setLayout(new BorderLayout());
	
			display = new JTextField();
			display.addActionListener(new ActionListener(){
				@Override
				public void actionPerformed(ActionEvent arg0) {
					calculate();
				}
			});
			this.add(display, BorderLayout.NORTH);
	
			InputAction action = new InputAction();
			panel = new JPanel();
			panel.setLayout(new GridLayout(5, 4));
			this.addButton("C", action);
			this.addButton("(", action);
			this.addButton(")", action);
			this.addButton("^", action);
	
			this.addButton("7", action);
			this.addButton("8", action);
			this.addButton("9", action);
			this.addButton("+", action);
	
			this.addButton("4", action);
			this.addButton("5", action);
			this.addButton("6", action);
			this.addButton("-", action);
	
			this.addButton("1", action);
			this.addButton("2", action);
			this.addButton("3", action);
			this.addButton("*", action);
	
			this.addButton("0", action);
			this.addButton(".", action);
			this.addButton("=", action);
			this.addButton("/", action);
	
			this.add(panel, BorderLayout.CENTER);
		}
	
		private void addButton(String label, ActionListener listener) {
			JButton btn = new JButton(label);
			btn.addActionListener(listener);
			panel.add(btn);
		}
	
		class InputAction implements ActionListener {
			public void actionPerformed(ActionEvent event) {
				String btnVal = event.getActionCommand();
				if (btnVal.equals("=")) {
					calculate();
				} else if(btnVal.equals("C")){
					display.setText("");
				} else {
					String input = display.getText().trim();
					display.setText(input + btnVal);
				}
			}
		}
	
		public void calculate() {
			String input = display.getText().trim();
			if (!Calculator.checkBalance(input)) {
				System.out.println("输入的表达式有误1");
			}
			try {
				double result = Calculator.calculateExpression(input, "_");
				String str = String.valueOf(result);
				if(str.endsWith(".0")){
					str = str.substring(0, str.length()-2);
				}
				display.setText(str);
			} catch (Exception e) {
				System.out.println("输入的表达式有误2");
			}
		}
	}

评论

1 楼 zxw961346704 2013-08-31  

值得学习的算法