java中實現四則運算代碼

最近上網查了一下,竟然沒有找到用Java編寫的四則運算的代碼,就小寫了一下.如有問題請大家反饋.

1.說明

代碼只是實現了簡單的四則運算,支持+,-,*,/,(,) 只能計算出正確的表達式的值,沒有對非法表達式進行校驗.

2.實現方法

第一步:將輸入的字符串轉換為List,主要是用來將String轉換為原子:數值/運算符/括號

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; } }

代碼原本是一個博客，原來代碼沒有註釋而且存在BUG，我稍微修稿了一哈添加了註釋。在這裡做個筆記，方便以後用

另為表示對原作者的敬意，附上原始代碼

/** * 四則運算表達式計算* @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); } }