控制台输入进行四则运算

package com.tarena.day14;

import java.util.LinkedList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Formula {
 private String formula;
 private double result;
 
 public Formula(String formula){
  this.formula = formula;
  calculate();//
 }
 
 public void calculate(){
  String regex = "\\([^\\(\\)]+\\)";
  Pattern p = Pattern.compile(regex);
  Matcher m = p.matcher(formula);
  while(m.find()){//先计算所有括号内部的东东
   String sub = m.group();
   String subFormula = sub.substring(1, sub.length()-1);
   String calVal = calculate(subFormula);
   formula = formula.replace(sub, calVal);
   formula = formula.replaceAll("\\-\\-", "+");//将--转换为+
   m = p.matcher(formula);
  }
  //再计算没有括号的最后式子
  result = Double.parseDouble(calculate(this.formula));
 }
 
 public String calculate(String formula){
  System.out.println("formula="+formula);
  LinkedList<String> numbers = new LinkedList<String>();
  Parser p = new Parser(formula);
  String s ;
  while((s=p.next())!=null){
   if(s.matches("\\-?\\d+(\\.\\d+)?")){
    numbers.add(s);
   }else if(s.matches("[\\*/]")){
    String n1 = numbers.removeLast();
    String n2 = p.next();
    String n3 = calculate(n1,s,n2);
    numbers.add(n3);
   }
  }
//  System.out.println(numbers);
  double result = 0;
  for(String str:numbers){//将数据累加
   result += Double.parseDouble(str);
  }
  System.out.println("result="+result);
  return String.valueOf(result);//将字符串解释为一个double类型的数据
 }
 public String calculate(String n1,String op,String n2){
  double d1 = Double.parseDouble(n1);
  double d2 = Double.parseDouble(n2);
  double d3=0;
  if("*".equals(op)){
   d3 = d1*d2;
  }else if("/".equals(op)){
   d3 = d1/d2;
  }
  return String.valueOf(d3);
 }
 public double getResult(){
  return result;
 }
 
 private class Parser{//内部类作为一个解释器
  String data;
  int index = 0;
  public Parser(String data){
   this.data = data;
  }
  public String next(){
   if(index>=data.length()){
    return null;
   }
   String regex = "\\-?\\d+(\\.\\d+)?|[\\+\\*/]";
   Pattern p = Pattern.compile(regex);
   Matcher m = p.matcher(data);
   if(m.find(index)){
    index = m.end();
    return m.group();
   }
   return null;
  }
  
 }//Parser
 
 public static void main(String[] args){
  Scanner sc = new Scanner(System.in);
  while(true){
   System.out.print("输入算式： ");
   String s = sc.nextLine();
   Formula f = new Formula(s);
   System.out.println(f.getResult());
  }
 }
}

 

以下是采用递归的方法计算四则运算：

package corejava.day14;

import java.util.LinkedList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
 * 采用递归的方法实现四则运算，
 */
public class Formula4 {
    private String formula;
    private double result;

    public Formula4(String formula) {
        this.formula = formula;
        result = Double.parseDouble(calculate(formula));
    }

    public String calculate(String formula) {
        System.out.println("formula=" + formula);
        if(formula.charAt(0)=='-'){
            formula = "0" + formula;
        }
        LinkedList<String> numbers = new LinkedList<String>();
        LinkedList<String> operators = new LinkedList<String>();
        Parser p = new Parser(formula);
        String reg1 = "\\(.+\\)";
        String s;
        while ((s = p.next()) != null) {
            if (s.matches(reg1)) {
                String subExpre = s.substring(1, s.length() - 1);
                s = calculate(subExpre);
                numbers.add(s);
            } else if (s.matches("\\d+(\\.\\d+)?")) {
                numbers.add(s);
            } else if (s.matches("[\\+\\-]")) {
                operators.add(s);
            } else if (s.matches("[\\*/]")) {
                String n1 = numbers.removeLast();
                String n2 = p.next();
                if (n2.matches(reg1)) {
                    String subExpre = n2.substring(1, n2.length() - 1);
                    n2 = calculate(subExpre);
                }
                String n3 = calculate(n1, s, n2);
                numbers.add(n3);
            }
        }
        System.out.println(numbers);
        System.out.println(operators);
        while(operators.size()>0){
            String n1 = numbers.removeFirst();
            String n2 = numbers.removeFirst();
            String op = operators.removeFirst();
            numbers.addFirst(calculate(n1, op, n2));
        }
        return String.valueOf(numbers.getFirst());// 将字符串解释为一个double类型的数据
    }

    public String calculate(String n1, String op, String n2) {
        double d1 = Double.parseDouble(n1);
        double d2 = Double.parseDouble(n2);
        double d3 = 0;
        if ("+".equals(op)) {
            d3 = d1 + d2;
        } else if ("-".equals(op)) {
            d3 = d1 - d2;
        } else if ("*".equals(op)) {
            d3 = d1 * d2;
        } else if ("/".equals(op)) {
            d3 = d1 / d2;
        }
        return String.valueOf(d3);
    }

    public double getResult() {
        return result;
    }

    class Parser {// 内部类，面向对象编程思想，模块化
        String data;
        int index = 0;

        public Parser(String data) {
            this.data = data;
        }

        public String next() {
            if (index >= data.length()) {
                return null;
            }
            String regex = "\\d+(\\.\\d+)?|[\\-\\+\\*/]|\\([^\\(\\)]+\\)|\\(.+\\)";
            Pattern p = Pattern.compile(regex);
            Matcher m = p.matcher(data);
            if (m.find(index)) {
                index = m.end();
                return m.group();
            }
            return null;
        }

    }// Parser

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.print("输入算式： ");
            String s = sc.nextLine();
            Formula4 f = new Formula4(s);
            System.out.println(f.getResult());
        }
    }
}