算术表达式求值(中缀转后缀,后缀求值，java 栈实现)

package com.operator;

import java.util.Arrays;
import java.util.LinkedList;

public class OperatorTest
{
	//定义一个枚举，来保持操作符
	enum OperartorEnum
	{
		additive("+"),//加号
		subtraction("-"),//减号
		multiplication("*"),//乘号
		division("/"),//除号
		leftbracket("("),//左括号
		rightbracket(")");//右括号
		private  String va;
		public String getVal()
		{
			return va;
		}
		OperartorEnum(String s)
		{
			va=s;
		}
	}
	
	public static void main(String[] args)
	{
		String s="3.8/2+222/(23-21)-45*2";//定义一个字符串表达式
		
		OperatorTest test=new OperatorTest();
		String[] inArr=test.ConvertStringToArr(s);
		System.out.println("中缀表达式:"+s+"="+(3.8/2+222/(23-21)-45*2));
		test.showArr(inArr);
		
		String[] poArr=test.ConvertIntoPofix(inArr);
		System.out.println("后缀表达式:");
		test.showArr(poArr);
		
		double result=test.CalculatePoix(poArr);
		System.out.println("后缀表达式的计算结果="+result);
		
	}
	
	//计算后缀表达式的值
	//基本思想，依次扫描后缀表达式，遇到数字则入栈；
	//遇到操作符，将栈顶的两个数字弹出，计算值，再入栈
	public double CalculatePoix(String[] poArr)
	{
		double result=0;
		double op1=0;
		double op2=0;
		LinkedList<String> list=new LinkedList<String>();//构造一个运算符栈
		
		for(String ch:poArr)
		{
			//如果遇到'+','-','*','/'，则计算
			if(ch.equals(OperartorEnum.additive.getVal())||
					ch.equals(OperartorEnum.subtraction.getVal())||
					ch.equals(OperartorEnum.multiplication.getVal())||
					ch.equals(OperartorEnum.division.getVal()))
			{
				op2=Double.valueOf(list.pop());// 先弹出的是第二个操作数，并删除
				op1=Double.valueOf(list.pop());// 先弹出的是第二个操作数,并删除
				list.push(String.valueOf(CalculateExpression(op1,op2,ch)));//计算值，再入栈
			}
			else
			{
				list.push(ch);//否则为数字，直接进栈
			}
		}
		
		//循环后，栈只剩下一个数字，即为最终的表达式的值
		result=Double.valueOf(list.pop());
		return result;
	}
	
	//计算一个最简单的二元运算表达式
	public double CalculateExpression(double op1,double op2,String op)
	{
		double result=0;
		if(op.equals(OperartorEnum.additive.getVal()))
		{
			result=op1+op2;
		}
		else if(op.equals(OperartorEnum.subtraction.getVal()))
		{
			result=op1-op2;
		}
		else if(op.equals(OperartorEnum.multiplication.getVal()))
		{
			result=op1*op2;
		}
		else if(op.equals(OperartorEnum.division.getVal()))
		{
			result=op1/op2;
		}
		return result;
	}
	
	//将中缀表达式转化为后缀表达式
	public String[] ConvertIntoPofix(String[] inArr)
	{
		LinkedList<String> list=new LinkedList<String>();
		
		int index=0;
		String poArr[]=new String[13];
		for(String s:inArr)
		{
			if(s!=null)
			{
				//如果是加号或者减号,将栈中操作符弹出，直到"("
				if(s.equals(OperartorEnum.additive.getVal())||s.equals(OperartorEnum.subtraction.getVal()))
				{
					while(!list.isEmpty())
					{
						String temp=list.getFirst();
						if(!temp.equals(OperartorEnum.leftbracket.getVal()))
						{
							poArr[index++]=list.pop();
						}
						else
						{
							break;
						}
						
						
					}
					list.push(s);
				}
				//如果为乘号或者除号，则弹出栈顶的除号和乘号，直到"("
				else if(s.equals(OperartorEnum.multiplication.getVal())||
						s.equals(OperartorEnum.division.getVal()))
				{
					while(!list.isEmpty())
					{
						String temp=list.getFirst();
						//如果为乘号，或者除号，并且不等于"("
						if((temp.equals(OperartorEnum.multiplication.getVal())||
								temp.equals(OperartorEnum.division.getVal())
								)&&
								(!temp.equals(OperartorEnum.leftbracket.getVal())))
						{
							poArr[index++]=list.pop();
						}
						else
						{
							break;
						}
					}
					list.push(s);
				}
				//遇到"(",直接进栈
				else if(s.equals(OperartorEnum.leftbracket.getVal()))
				{
					list.push(s);
				}
				//如果遇到右括号，则将栈顶的操作符弹出，直到"(",再删除"("
				else if(s.equals(OperartorEnum.rightbracket.getVal()))
				{
					while(!list.isEmpty())
					{
						String temp=list.getFirst();
						if(!temp.equals(OperartorEnum.leftbracket.getVal()))
						{
							poArr[index++]=list.pop();
						}
						else
						{
							break;
						}
					}
					list.pop();
				}
				else
				{
					poArr[index++]=s;
				}
				
				//System.out.println("后缀为:"+Arrays.toString(poArr)+",栈为:"+list );
			}
		}
		
		while(!list.isEmpty())
		{
			poArr[index++]=list.pop();
			//System.out.println("后缀为:"+Arrays.toString(poArr)+",栈为:"+list );
		}
		
		return poArr;
	}
	
	//将一个字符串表达式转换为一个数组
	public  String[] ConvertStringToArr(String s)
	{
		
		
		String arr[]=new String[s.length()];
		
		int index=0;
		for(int i=0;i<s.length();)
		{
			String ch=String.valueOf(s.charAt(i));
			if(ch.equals(OperartorEnum.additive.getVal())||
					ch.equals(OperartorEnum.subtraction.getVal())||
					ch.equals(OperartorEnum.multiplication.getVal())||
					ch.equals(OperartorEnum.division.getVal())||
					ch.equals(OperartorEnum.leftbracket.getVal())||
					ch.equals(OperartorEnum.rightbracket.getVal()))
			{
				arr[index++]=ch;
				i++;
			}
			else
			{
				int end=SearchEnd(s,i);
				arr[index++]=s.substring(i, end);
				i=end;
			}
		}

		return arr;
	}
	
	//查找一个数的结束索引(这样做的原因是一个数可能是多位的，并且带有小数点)
	private  int SearchEnd(String s,int index)
	{
		int result=index;
		int i=0;
		for(i=index;i<s.length();i++)
		{
			String ch=String.valueOf(s.charAt(i));
			if(ch.equals(OperartorEnum.additive.getVal())||
					ch.equals(OperartorEnum.subtraction.getVal())||
					ch.equals(OperartorEnum.multiplication.getVal())||
					ch.equals(OperartorEnum.division.getVal())||
					ch.equals(OperartorEnum.leftbracket.getVal())||
					ch.equals(OperartorEnum.rightbracket.getVal()))
			{
			
				result=i;
				break;
			}
		}
		if(i==s.length())
		{
			result=s.length();
		}
		return result;
	}
	
	//打印一个数组
	private void showArr(String[] arr)
	{
		
		for(String ss: arr)
		{
			System.out.println(ss!=null?ss:"");
			
		}
		
	}

}

运行结果: