java中实现四则运算代码

public List transStr(String str) { List strList = new ArrayList();  /* 获取提出数据的符号串 */ String tmp = str.replaceAll("//d*", ""); /* 记录当前的运算符 */ String curLet = null; /* 记录tmp字符串中第一个运算符的位置 */ int loc = 0; /* 符号串长度 */ int len = tmp.length(); for (int i = 0; i < len; i++) {  curLet = tmp.substring(i, i + 1);  loc = str.indexOf(curLet);  /* 如果当前处理字符为( 或者 ) */  if (!"".equals(str.substring(0, loc).trim()))  {  strList.add(str.substring(0, loc).trim());  }  strList.add(str.substring(loc, loc + 1));  str = str.substring(loc + 1); } if (0 < str.length()) {  strList.add(str.trim()); } return strList; }

public String[] midToEnd(List midList) { Stack embl = new Stack(); Stack result = new Stack();  Iterator it = midList.iterator(); String curStr = null; while (it.hasNext()) {  curStr = (String) it.next();    /* 确认是否式字符串 */  if(sign.containsKey(curStr))  {  /* 如果符号栈为空 或者符号为( */  if (0 == embl.size() || "(".equals(curStr))  {   embl.push(curStr);  }  else  {   /*如果符号为) 符号栈需要出栈,直到匹配一个(为止 */   if(")".equals(curStr))   {   while(!"(".equals((String)embl.peek()))   {    if(0 >= embl.size())    {    return null;    }    result.push(embl.pop());   }   embl.pop();   }   else   {   int p1 = Integer.parseInt((String) sign.get(curStr));   int p2 = Integer.parseInt((String) sign.get(embl.peek()));      /* 如果当前字符的优先级大于栈顶符号的优先级 */   if (p1 > p2)   {    embl.push(curStr);   }   else   {    while (p1 <= p2 || embl.size() > 0)    {    result.push(embl.pop());    if(0 == embl.size())    {     break;    }    p2 = Integer.parseInt((String) sign.get(embl.peek()));    }    embl.push(curStr);   }   }  }  }  else  {  result.push(curStr);  } }  while (0 < embl.size()) {  result.push(embl.pop()); }  int len = result.size(); String[] ret = new String[len]; for (int i = 0; i < len; i++) {  ret[len - i - 1] = (String) result.pop(); }  return ret; }

/** * 解析后缀表达式,返回对应的运算结果 * @param String[] endStr 转换后的后缀表达式 * @return Object 返回运算结果 如果表达式有误直接打印"Input Error" */ public Object calculate(String[] endStr) { int len = endStr.length; Stack calc = new Stack(); double p2; double p1; for (int i = 0; i < len; i++) {  if (sign.containsKey(endStr[i]))  {  try  {   p2 = Double.parseDouble((String) calc.pop());   p1 = Double.parseDouble((String) calc.pop());   calc.push(String.valueOf(simpleCalc(p1, p2,endStr[i])));  }  catch(NumberFormatException ex)  {   ex.printStackTrace();   return "Input Error";  }  catch(Exception ex)  {   ex.printStackTrace();   return "Input Error";  }  }  else  {  calc.push(endStr[i]);  } }  if (1 == calc.size()) {  return calc.pop(); } else {  return "Input Error"; } }  /** * 实现底层的运算函数 * @param double p1 数字1 * @param double p1 数字2 * @param String oper 运算符 +-/* */ public double simpleCalc(double p1, double p2, String oper) {  switch(oper.charAt(0)) {   case '+':     return p1 + p2;   case '-':     return p1 - p2;   case '*':     return p1 * p2;   case '/':     return p1 / p2;   default:    return p1; } }

 private static HashMap sign = new HashMap(); /* 将运算符的优先级放入到缓存处理 */ public CalculateExp() { sign.put(")", "3"); sign.put("*", "2"); sign.put("/", "2"); sign.put("+", "1"); sign.put("-", "1"); sign.put("(", "0"); }

import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Stack;/** * Java实现计算表达式 * 只实现有加减乘除以及括号的运算 * 例如: 3+12+25*(20-20/4)+10 * @author GuoBo 2009-3-16 * @version 1.0 */public class CalculateExp{	private static HashMap sign = new HashMap();	/* 将运算符的优先级放入到缓存处理 */	public CalculateExp()	{		sign.put(")", "3");		sign.put("*", "2");		sign.put("/", "2");		sign.put("+", "1");		sign.put("-", "1");		sign.put("(", "0");	}	/**	 * @param String 输入的表达式	 * @return List 解析后的字符串元素	 * 对输入的字符串进行解析	 * 转换为需要处理的数据	 * 例如:3+12+25*(20-20/4)+10	 * 转换后的结果为:	 * List 元素为 ret = {3,+,12,+,25,*,(,20,-,20,-,20,/,4,),+,10}	 */	public List transStr(String str)	{		List strList = new ArrayList();				/* 获取提出数据的符号串 */		String tmp = str.replaceAll("//d*", "");		/* 记录当前的运算符 */		String curLet = null;		/* 记录tmp字符串中第一个运算符的位置 */		int loc = 0;		/* 符号串长度 */		int len = tmp.length();		for (int i = 0; i < len; i++)		{			curLet = tmp.substring(i, i + 1);			loc = str.indexOf(curLet);			/* 如果当前处理字符为( 或者 ) */			if (!"".equals(str.substring(0, loc).trim()))			{				strList.add(str.substring(0, loc).trim());			}			strList.add(str.substring(loc, loc + 1));			str = str.substring(loc + 1);		}		if (0 < str.length())		{			strList.add(str.trim());		}		return strList;	}	/**	 * 将表达式从中缀表达式转换为后缀表达式(波兰式)	 * @Param List 解析后的表达式的列表	 * @return String[] 转换后的表达式字符串数组	 */	public String[] midToEnd(List midList)	{		Stack embl = new Stack();		Stack result = new Stack();				Iterator it = midList.iterator();		String curStr = null;		while (it.hasNext())		{			curStr = (String) it.next();						/* 确认是否式字符串 */			if(sign.containsKey(curStr))			{				/* 如果符号栈为空 或者符号为( */				if (0 == embl.size() || "(".equals(curStr))				{					embl.push(curStr);				}				else				{					/*如果符号为) 符号栈需要出栈,直到匹配一个(为止 */					if(")".equals(curStr))					{						while(!"(".equals((String)embl.peek()))						{							if(0 >= embl.size())							{								return null;							}							result.push(embl.pop());						}						embl.pop();					}					else					{						int p1 = Integer.parseInt((String) sign.get(curStr));						int p2 = Integer.parseInt((String) sign.get(embl.peek()));												/* 如果当前字符的优先级大于栈顶符号的优先级 */						if (p1 > p2)						{							embl.push(curStr);						}						else						{							while (p1 <= p2 || embl.size() > 0)							{								result.push(embl.pop());								if(0 == embl.size())								{									break;								}								p2 = Integer.parseInt((String) sign.get(embl.peek()));							}							embl.push(curStr);						}					}				}			}			else			{				result.push(curStr);			}		}				while (0 < embl.size())		{			result.push(embl.pop());		}				int len = result.size();		String[] ret = new String[len];		for (int i = 0; i < len; i++)		{			ret[len - i - 1] = (String) result.pop();		}				return ret;	}		/**	 * 解析后缀表达式,返回对应的运算结果	 * @param String[] endStr 转换后的后缀表达式	 * @return Object 返回运算结果 如果表达式有误直接打印"Input Error"	 */	public Object calculate(String[] endStr)	{		int len = endStr.length;		Stack calc = new Stack();		double p2;		double p1;		for (int i = 0; i < len; i++)		{			if (sign.containsKey(endStr[i]))			{				try				{					p2 = Double.parseDouble((String) calc.pop());					p1 = Double.parseDouble((String) calc.pop());					calc.push(String.valueOf(simpleCalc(p1, p2,endStr[i])));				}				catch(NumberFormatException ex)				{					ex.printStackTrace();					return "Input Error";				}				catch(Exception ex)				{					ex.printStackTrace();					return "Input Error";				}			}			else			{				calc.push(endStr[i]);			}		}				if (1 == calc.size())		{			return calc.pop();		}		else		{			return "Input Error";		}	}		/**	 * 实现底层的运算函数	 * @param double p1 数字1	 * @param double p1 数字2	 * @param String oper 运算符 +-/*	 */	public double simpleCalc(double p1, double p2, String oper)	{				switch(oper.charAt(0))		{		  case '+':		    return p1 + p2;		  case '-':		    return p1 - p2;		  case '*':		    return p1 * p2;		  case '/':		    return p1 / p2;		  default:		  	return p1;		}	}		/**	 * 主控函数	 */	public static void main(String[] args)	{		CalculateExp ce = new CalculateExp();		String tmp = "3+12+25*(20-20/4+10";		String ret = (String) ce.calculate(ce.midToEnd(ce				.transStr(tmp)));		double value = 0;    try    {    	value = Double.parseDouble(ret);    }    catch (NumberFormatException ex)    {    	System.out.print(ret);    }		System.out.print(value);	}}

import java.math.BigDecimal;import java.util.regex.Matcher;import java.util.regex.Pattern;/** * 计算器工具类 * @author shuqi * @date 2015-7-23 * @version since 1.0 */public class CalculatorUtil { public static BigDecimal arithmetic(String exp){  if(!exp.matches("//d+")){   String result = parseExp(exp).replaceAll("[//[//]]", "");   return new BigDecimal(result);  }else{   return new BigDecimal(exp);  } } /**  * 最小计数单位  *   */ private static String minExp="^((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//]))[//+//-//*///]((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//]))$"; /**  * 不带括号的运算  */ private static String noParentheses="^[^//(//)]+$"; /**  * 匹配乘法或者除法  */ private static String priorOperatorExp="(((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//]))[//*///]((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//])))"; /**  * 匹配加法和减法  */ private static String operatorExp="(((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//]))[//+//-]((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//])))"; /**  * 匹配只带一个括号的  */ private static String minParentheses="//([^//(//)]+//)";  /**  * 解析计算四则运算表达式，例：2+((3+4)*2-22)/2*3  * @param expression  * @return  */ private static String parseExp(String expression){  //方法进入 先替换空格，在去除运算两边的()号  expression=expression.replaceAll("//s+", "").replaceAll("^//(([^//(//)]+)//)$", "$1");    //最小表达式计算  if(expression.matches(minExp)){   String result=calculate(expression);   return Double.parseDouble(result)>=0?result:"["+result+"]";  }  //计算不带括号的四则运算  if(expression.matches(noParentheses)){   Pattern patt=Pattern.compile(priorOperatorExp);   Matcher mat=patt.matcher(expression);   if(mat.find()){    String tempMinExp=mat.group();    expression=expression.replaceFirst(priorOperatorExp, parseExp(tempMinExp));   }else{    patt=Pattern.compile(operatorExp);    mat=patt.matcher(expression);        if(mat.find()){     String tempMinExp=mat.group();     expression=expression.replaceFirst(operatorExp, parseExp(tempMinExp));    }   }   return parseExp(expression);  }    //计算带括号的四则运算  Pattern patt=Pattern.compile(minParentheses);  Matcher mat=patt.matcher(expression);  if(mat.find()){   String tempMinExp=mat.group();   expression=expression.replaceFirst(minParentheses, parseExp(tempMinExp));  }  return parseExp(expression); } /**  * 计算最小单位四则运算表达式（两个数字）  * @param exp  * @return  */ private static String calculate(String exp){  exp=exp.replaceAll("[//[//]]", "");  String number[]=exp.replaceFirst("(//d)[//+//-//*///]", "$1,").split(",");  BigDecimal number1=new BigDecimal(number[0]);  BigDecimal number2=new BigDecimal(number[1]);  BigDecimal result=null;    String operator=exp.replaceFirst("^.*//d([//+//-//*///]).+$", "$1");  if("+".equals(operator)){   result=number1.add(number2);  }else if("-".equals(operator)){   result=number1.subtract(number2);  }else if("*".equals(operator)){   result=number1.multiply(number2);  }else if("/".equals(operator)){   //第二个参数为精度，第三个为四色五入的模式   result=number1.divide(number2,5,BigDecimal.ROUND_CEILING);  }    return result!=null?result.toString():null; } }

/** * 四则运算表达式计算 * @author penli * */public class Arithmetic { public static void main(String args[]){ System.out.println(arithmetic("2.2+((3+4)*2-22)/2*3.2")); } public static double arithmetic(String exp){ String result = parseExp(exp).replaceAll("[//[//]]", ""); return Double.parseDouble(result); } /** * 解析计算四则运算表达式，例：2+((3+4)*2-22)/2*3 * @param expression * @return */ public static String parseExp(String expression){ //String numberReg="^((?!0)//d+(//.//d+(?<!0))?)|(0//.//d+(?<!0))$"; expression=expression.replaceAll("//s+", "").replaceAll("^//((.+)//)$", "$1"); String checkExp="//d"; String minExp="^((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//]))[//+//-//*///]((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//]))$"; //最小表达式计算 if(expression.matches(minExp)){ String result=calculate(expression);  return Double.parseDouble(result)>=0?result:"["+result+"]"; } //计算不带括号的四则运算 String noParentheses="^[^//(//)]+$"; String priorOperatorExp="(((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//]))[//*///]((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//])))"; String operatorExp="(((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//]))[//+//-]((//d+(//.//d+)?)|(//[//-//d+(//.//d+)?//])))"; if(expression.matches(noParentheses)){ Pattern patt=Pattern.compile(priorOperatorExp); Matcher mat=patt.matcher(expression); if(mat.find()){ String tempMinExp=mat.group(); expression=expression.replaceFirst(priorOperatorExp, parseExp(tempMinExp)); }else{ patt=Pattern.compile(operatorExp); mat=patt.matcher(expression);  if(mat.find()){  String tempMinExp=mat.group();  expression=expression.replaceFirst(operatorExp, parseExp(tempMinExp)); } } return parseExp(expression); } //计算带括号的四则运算 String minParentheses="//([^//(//)]+//)"; Pattern patt=Pattern.compile(minParentheses); Matcher mat=patt.matcher(expression); if(mat.find()){ String tempMinExp=mat.group(); expression=expression.replaceFirst(minParentheses, parseExp(tempMinExp)); } return parseExp(expression); } /** * 计算最小单位四则运算表达式（两个数字） * @param exp * @return */ public static String calculate(String exp){ exp=exp.replaceAll("[//[//]]", ""); String number[]=exp.replaceFirst("(//d)[//+//-//*///]", "$1,").split(","); BigDecimal number1=new BigDecimal(number[0]); BigDecimal number2=new BigDecimal(number[1]); BigDecimal result=null;  String operator=exp.replaceFirst("^.*//d([//+//-//*///]).+$", "$1"); if("+".equals(operator)){ result=number1.add(number2); }else if("-".equals(operator)){ result=number1.subtract(number2); }else if("*".equals(operator)){ result=number1.multiply(number2); }else if("/".equals(operator)){ result=number1.divide(number2); }  return result!=null?result.toString():null; }}

import java.util.Stack; /**  * 利用栈，进行四则运算的类  * 用两个栈来实现算符优先，一个栈用来保存需要计算的数据numStack,一个用来保存计算优先符priStack  *  * 基本算法实现思路为：用当前取得的运算符与priStack栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；  * 若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；  * 若小于，则同理，取出栈顶元素运算，将结果入操作数栈。各个优先级'(' > '*' = '/' > '+' = '-' > ')'  *  */  public class Operate {   private Stack<Character> priStack = new Stack<Character>();// 操作符栈   private Stack<Integer> numStack = new Stack<Integer>();;// 操作数栈     /**   * 传入需要解析的字符串，返回计算结果(此处因为时间问题，省略合法性验证)   * @param str 需要进行技术的表达式   * @return 计算结果   */   public int caculate(String str) {    // 1.判断string当中有没有非法字符    String temp;// 用来临时存放读取的字符    // 2.循环开始解析字符串，当字符串解析完，且符号栈为空时，则计算完成    StringBuffer tempNum = new StringBuffer();// 用来临时存放数字字符串(当为多位数时)    StringBuffer string = new StringBuffer().append(str);// 用来保存，提高效率      while (string.length() != 0) {     temp = string.substring(0, 1);     string.delete(0, 1);     // 判断temp，当temp为操作符时     if (!isNum(temp)) {      // 1.此时的tempNum内即为需要操作的数，取出数，压栈，并且清空tempNum      if (!"".equals(tempNum.toString())) {       // 当表达式的第一个符号为括号       int num = Integer.parseInt(tempNum.toString());       numStack.push(num);      tempNum.delete(0, tempNum.length());      }      // 用当前取得的运算符与栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；      // 若小于，则同理，取出栈顶元素运算，将结果入操作数栈。        // 判断当前运算符与栈顶元素优先级，取出元素，进行计算(因为优先级可能小于栈顶元素，还小于第二个元素等等，需要用循环判断)      while (!compare(temp.charAt(0)) && (!priStack.empty())) {      int a = (int) numStack.pop();// 第二个运算数       int b = (int) numStack.pop();// 第一个运算数       char ope = priStack.pop();       int result = 0;// 运算结果       switch (ope) {       // 如果是加号或者减号，则       case '+':        result = b + a;        // 将操作结果放入操作数栈        numStack.push(result);        break;       case '-':        result = b - a;        // 将操作结果放入操作数栈        numStack.push(result);        break;       case '*':        result = b * a;        // 将操作结果放入操作数栈        numStack.push(result);        break;       case '/':        result = b / a;// 将操作结果放入操作数栈        numStack.push(result);        break;       }        }      // 判断当前运算符与栈顶元素优先级， 如果高，或者低于平，计算完后，将当前操作符号，放入操作符栈      if (temp.charAt(0) != '#') {       priStack.push(new Character(temp.charAt(0)));       if (temp.charAt(0) == ')') {// 当栈顶为'('，而当前元素为')'时，则是括号内以算完，去掉括号        priStack.pop();        priStack.pop();       }      }     } else      // 当为非操作符时（数字）      tempNum = tempNum.append(temp);// 将读到的这一位数接到以读出的数后(当不是个位数的时候)    }    return numStack.pop();   }     /**   * 判断传入的字符是不是0-9的数字   *   * @param str   *   传入的字符串   * @return   */   private boolean isNum(String temp) {    return temp.matches("[0-9]");   }     /**   * 比较当前操作符与栈顶元素操作符优先级，如果比栈顶元素优先级高，则返回true，否则返回false   *   * @param str 需要进行比较的字符   * @return 比较结果 true代表比栈顶元素优先级高，false代表比栈顶元素优先级低   */   private boolean compare(char str) {    if (priStack.empty()) {     // 当为空时，显然 当前优先级最低，返回高     return true;    }    char last = (char) priStack.lastElement();    // 如果栈顶为'('显然，优先级最低，')'不可能为栈顶。    if (last == '(') {     return true;    }    switch (str) {    case '#':     return false;// 结束符    case '(':     // '('优先级最高,显然返回true     return true;    case ')':     // ')'优先级最低，     return false;    case '*': {     // '*/'优先级只比'+-'高     if (last == '+' || last == '-')      return true;     else      return false;    }    case '/': {     if (last == '+' || last == '-')      return true;     else      return false;    }     // '+-'为最低，一直返回false    case '+':     return false;    case '-':     return false;    }    return true;   }     public static void main(String args[]) {    Operate operate = new Operate();    int t = operate.caculate("(3+4*(4*10-10/2)#");    System.out.println(t);   }    }