Java实现四则混合运算代码示例
使用栈来实现，可以处理运算优先级。
使用自然四则运算表达式即可，如：4+(3*(3-1)+2)/2。无需把表达式先转换为逆波兰等形式。
packagecom.joshua.cal;
importjava.util.Collections;
importjava.util.HashMap;
importjava.util.HashSet;
importjava.util.LinkedList;
importjava.util.List;
importjava.util.Map;
importjava.util.Set;
importjava.util.Stack;
publicclassCalculator{
privatefinalStacknumStack=newStack();
privatefinalStackopStack=newStack();
privatecharcurrentOperator;
privatecharopStackTop;
privateinti;
privateStringexpression;
@SuppressWarnings("rawtypes")
publicvoidexec(Stringexpression){
try{
clean();
if(expression==null||expression.isEmpty()){
thrownewIllegalArgumentException("BlankExpression!");
}
this.expression=expression;
opStack.push(TERMINATE_TOKENS.START_END_MARK);
Listtokens=TOKENIZER.exec(expression
+TERMINATE_TOKENS.START_END_MARK);
for(;i':
processStackHigerPriorityOperator();
break;
case'<':
processStackLowerPriorityOperator();
break;
case'=':
processStackEqualPriorityOperator();
break;
default:
break;
}
}
privatevoidprocessStackLowerPriorityOperator(){
opStack.push(currentOperator);
}
privatevoidprocessStackHigerPriorityOperator(){
numStack.push(CALCULATE.exec(opStack.pop(),numStack.pop(),
numStack.pop()));
--i;//pointerbacktothepreviousoperator.
}
privatevoidprocessStackEqualPriorityOperator(){
if(TERMINATE_TOKENS.START_END_MARK==currentOperator){
System.out.println(expression+"="+numStack.peek());
}elseif(')'==currentOperator){
opStack.pop();
}
}
publicvoidclean(){
numStack.clear();
opStack.clear();
i=0;
}
publicstaticvoidmain(String[]args){
Calculatorcal=newCalculator();
cal.exec("4+(3*(3-1)+2)/2");//=8
cal.exec("4+(-3*(3-1)+2)");//=0
cal.exec("4+-/(-3*(3-1)+2)");//incorrectexpression!
cal.exec("4.5+(3.2+3)/2");//=7.6
cal.exec("4.5+(3.2:3)/2");//incorrectexpression!
cal.exec("-4.5+(3.2-3)/2");//=-4.4
}
}
enumCALCULATE{
INSTANCE;
publicstaticdoubleexec(finalcharoperator,finaldoubleright,
finaldoubleleft){
switch(operator){
case'+':
returnleft+right;
case'-':
returnleft-right;
case'*':
returnleft*right;
case'/':
returnleft/right;
default:
thrownewIllegalArgumentException("Unsupportedoperator:"
+operator);
}
}
}
enumTERMINATE_TOKENS{
INSTANCE;
publicstaticfinalcharSTART_END_MARK='#';
privatestaticfinalMapTOKENs=newHashMap();
static{
//token,tokenid
TOKENs.put('+',0);
TOKENs.put('-',1);
TOKENs.put('*',2);
TOKENs.put('/',3);
TOKENs.put('(',4);
TOKENs.put(')',5);
TOKENs.put(START_END_MARK,6);
}
privatestaticSetNEGATIVE_NUM_SENSITIVE=newHashSet();
publicstaticsynchronizedSetgetNegativeNumSensitiveToken(){
if(NEGATIVE_NUM_SENSITIVE.size()==0){
NEGATIVE_NUM_SENSITIVE.addAll(TOKENs.keySet());
NEGATIVE_NUM_SENSITIVE.remove(')');
}
returnNEGATIVE_NUM_SENSITIVE;
}
publicstaticbooleanisTerminateToken(finalchartoken){
Setkeys=TOKENs.keySet();
returnkeys.contains(token);
}
publicstaticintgetTokenId(finalchartoken){
returnTOKENs.get(token)==null?-1:TOKENs.get(token);
}
publicstaticintgetTokenSize(){
returnTOKENs.size();
}
}
enumCALCULATE_MODE{
INSTANCE;
privatestaticchar[][]RULES={
//+-*/()#
{'>','>','<','<','<','>','>'},//+
{'>','>','<','<','<','>','>'},//-
{'>','>','>','>','<','>','>'},//*
{'>','>','>','>','<','>','>'},///
{'<','<','<','<','<','=','o'},//(
{'>','>','>','>','o','>','>'},//)
{'<','<','<','<','<','o','='},//#
};
static{
if(RULES.length!=TERMINATE_TOKENS.getTokenSize()||RULES.length<1
||RULES[0].length!=TERMINATE_TOKENS.getTokenSize()){
thrownewIllegalArgumentException("Rulesmatrixisincorrect!");
}
}
publicstaticchargetRule(finalcharcurrentOperator,finalcharopStackTop){
try{
returnRULES[TERMINATE_TOKENS.getTokenId(opStackTop)][TERMINATE_TOKENS
.getTokenId(currentOperator)];
}catch(Throwablee){
thrownewRuntimeException("Norulesweredefinedforsometoken!");
}
}
}
enumTOKENIZER{
INSTANCE;
privatestaticfinalStringBuilderBUFFER=newStringBuilder();
privatestaticStringclearExpression(Stringexpression){
returnexpression.replaceAll("","");
}
privatestaticCharacterPREVIOUS_CHAR;
privatestaticvoidclean(){
BUFFER.delete(0,BUFFER.length());
PREVIOUS_CHAR=null;
}
privatestaticbooleanprocessNegativeNumbers(finalStringexp,
finalintindex){
charc=exp.charAt(index);
if(('+'==c||'-'==c)
&&(PREVIOUS_CHAR==null||TERMINATE_TOKENS
.getNegativeNumSensitiveToken().contains(PREVIOUS_CHAR))
&&!TERMINATE_TOKENS.isTerminateToken(exp.charAt(index+1))){
BUFFER.append(c);
returntrue;
}
returnfalse;
}
@SuppressWarnings({"unchecked","rawtypes"})
publicstaticListexec(finalStringexpression){
clean();
Stringexp=clearExpression(expression);
Listresult=newLinkedList();
for(inti=0;i0){
result.add(Double.valueOf(BUFFER.toString()));
BUFFER.delete(0,BUFFER.length());
}
result.add(c);
}else{
BUFFER.append(c);
}
PREVIOUS_CHAR=c;
}
returnCollections.unmodifiableList(result);
}
}
输出
4+(3*(3-1)+2)/2=8.0 4+(-3*(3-1)+2)=0.0 4.5+(3.2+3)/2=7.6 -4.5+(3.2-3)/2=-4.4 IncorretExpression:4+-/(-3*(3-1)+2) Error:null IncorretExpression:4.5+(3.2:3)/2 Error:Forinputstring:"3.2:3"
总结
以上就是本文关于Java实现四则混合运算代码示例的全部内容，希望对大家有所帮助。感兴趣的朋友可以参阅：大话Java混合运算规则 浅谈Java变量赋值运算符及相关实例 Java大数字运算之BigInteger 等，有什么问题可以随时留言，小编会及时回复大家的。感谢朋友们对毛票票网站的支持。