欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

java中實(shí)現(xiàn)四則運(yùn)算代碼

 更新時(shí)間:2015年08月25日 08:58:14   投稿:hebedich  
本文給大家分享了幾個(gè)java中實(shí)現(xiàn)四則運(yùn)算的代碼,有個(gè)人的也有網(wǎng)友的,代碼寫的不是很好,難免會有BUG,忘發(fā)現(xiàn)BUG的親們能提醒我下,好讓我改進(jìn)

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

1.說明

代碼只是實(shí)現(xiàn)了簡單的四則運(yùn)算,支持+,-,*,/,(,) 只能計(jì)算出正確的表達(dá)式的值,沒有對非法表達(dá)式進(jìn)行校驗(yàn).

2.實(shí)現(xiàn)方法

第一步:將輸入的字符串轉(zhuǎn)換為List,主要是用來將String轉(zhuǎn)換為原子:數(shù)值/運(yùn)算符/括號

public List transStr(String str)
 {
 List strList = new ArrayList();
 
 /* 獲取提出數(shù)據(jù)的符號串 */
 String tmp = str.replaceAll("\\d*", "");
 /* 記錄當(dāng)前的運(yùn)算符 */
 String curLet = null;
 /* 記錄tmp字符串中第一個(gè)運(yùn)算符的位置 */
 int loc = 0;
 /* 符號串長度 */
 int len = tmp.length();
 for (int i = 0; i < len; i++)
 {
  curLet = tmp.substring(i, i + 1);
  loc = str.indexOf(curLet);
  /* 如果當(dāng)前處理字符為( 或者 ) */
  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;
 }

第二步: 將原來的中綴表達(dá)式轉(zhuǎn)換為后綴表達(dá)式,在四則運(yùn)算中,后綴表達(dá)式是最方便計(jì)算的

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();
  
  /* 確認(rèn)是否式字符串 */
  if(sign.containsKey(curStr))
  {
  /* 如果符號棧為空 或者符號為( */
  if (0 == embl.size() || "(".equals(curStr))
  {
   embl.push(curStr);
  }
  else
  {
   /*如果符號為) 符號棧需要出棧,直到匹配一個(gè)(為止 */
   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()));
   
   /* 如果當(dāng)前字符的優(yōu)先級大于棧頂符號的優(yōu)先級 */
   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;
 }

第三步:將解析后綴表達(dá)式,返回計(jì)算的最終結(jié)果

/**
 * 解析后綴表達(dá)式,返回對應(yīng)的運(yùn)算結(jié)果
 * @param String[] endStr 轉(zhuǎn)換后的后綴表達(dá)式
 * @return Object 返回運(yùn)算結(jié)果 如果表達(dá)式有誤直接打印"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";
 }
 }
 
 /**
 * 實(shí)現(xiàn)底層的運(yùn)算函數(shù)
 * @param double p1 數(shù)字1
 * @param double p1 數(shù)字2
 * @param String oper 運(yùn)算符 +-/*
 */
 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;
 }
 }

第四步:運(yùn)算符的優(yōu)先級放在了緩存中進(jìn)行提取

 private static HashMap sign = new HashMap();
 /* 將運(yùn)算符的優(yōu)先級放入到緩存處理 */
 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實(shí)現(xiàn)計(jì)算表達(dá)式
 * 只實(shí)現(xiàn)有加減乘除以及括號的運(yùn)算
 * 例如: 3+12+25*(20-20/4)+10
 * @author GuoBo 2009-3-16
 * @version 1.0
 */
public class CalculateExp
{
	private static HashMap sign = new HashMap();
	/* 將運(yùn)算符的優(yōu)先級放入到緩存處理 */
	public CalculateExp()
	{
		sign.put(")", "3");
		sign.put("*", "2");
		sign.put("/", "2");
		sign.put("+", "1");
		sign.put("-", "1");
		sign.put("(", "0");
	}
	/**
	 * @param String 輸入的表達(dá)式
	 * @return List 解析后的字符串元素
	 * 對輸入的字符串進(jìn)行解析
	 * 轉(zhuǎn)換為需要處理的數(shù)據(jù)
	 * 例如:3+12+25*(20-20/4)+10
	 * 轉(zhuǎn)換后的結(jié)果為:
	 * List 元素為 ret = {3,+,12,+,25,*,(,20,-,20,-,20,/,4,),+,10}
	 */
	public List transStr(String str)
	{
		List strList = new ArrayList();
		
		/* 獲取提出數(shù)據(jù)的符號串 */
		String tmp = str.replaceAll("\\d*", "");
		/* 記錄當(dāng)前的運(yùn)算符 */
		String curLet = null;
		/* 記錄tmp字符串中第一個(gè)運(yùn)算符的位置 */
		int loc = 0;
		/* 符號串長度 */
		int len = tmp.length();
		for (int i = 0; i < len; i++)
		{
			curLet = tmp.substring(i, i + 1);
			loc = str.indexOf(curLet);
			/* 如果當(dāng)前處理字符為( 或者 ) */

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

	/**
	 * 將表達(dá)式從中綴表達(dá)式轉(zhuǎn)換為后綴表達(dá)式(波蘭式)
	 * @Param List 解析后的表達(dá)式的列表
	 * @return String[] 轉(zhuǎn)換后的表達(dá)式字符串?dāng)?shù)組
	 */
	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();
			
			/* 確認(rèn)是否式字符串 */
			if(sign.containsKey(curStr))
			{
				/* 如果符號棧為空 或者符號為( */
				if (0 == embl.size() || "(".equals(curStr))
				{
					embl.push(curStr);
				}
				else
				{
					/*如果符號為) 符號棧需要出棧,直到匹配一個(gè)(為止 */
					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()));
						
						/* 如果當(dāng)前字符的優(yōu)先級大于棧頂符號的優(yōu)先級 */
						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;
	}
	
	/**
	 * 解析后綴表達(dá)式,返回對應(yīng)的運(yùn)算結(jié)果
	 * @param String[] endStr 轉(zhuǎn)換后的后綴表達(dá)式
	 * @return Object 返回運(yùn)算結(jié)果 如果表達(dá)式有誤直接打印"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";
		}
	}
	
	/**
	 * 實(shí)現(xiàn)底層的運(yùn)算函數(shù)
	 * @param double p1 數(shù)字1
	 * @param double p1 數(shù)字2
	 * @param String oper 運(yùn)算符 +-/*
	 */
	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;
		}
	}
	
	/**
	 * 主控函數(shù)
	 */
	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);
	}
}

以下是其他網(wǎng)友的補(bǔ)充

代碼的思路是通過正則判斷計(jì)算每個(gè)最小的計(jì)算單元。以下是代碼:

import java.math.BigDecimal;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 計(jì)算器工具類
 * @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);
  }
 }
 /**
  * 最小計(jì)數(shù)單位
  * 
  */
 private static String minExp="^((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))$";
 /**
  * 不帶括號的運(yùn)算
  */
 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+)?\\])))";
 /**
  * 匹配只帶一個(gè)括號的
  */
 private static String minParentheses="\\([^\\(\\)]+\\)";
 
 /**
  * 解析計(jì)算四則運(yùn)算表達(dá)式,例:2+((3+4)*2-22)/2*3
  * @param expression
  * @return
  */
 private static String parseExp(String expression){
  //方法進(jìn)入 先替換空格,在去除運(yùn)算兩邊的()號
  expression=expression.replaceAll("\\s+", "").replaceAll("^\\(([^\\(\\)]+)\\)$", "$1");
  
  //最小表達(dá)式計(jì)算
  if(expression.matches(minExp)){
   String result=calculate(expression);
   return Double.parseDouble(result)>=0?result:"["+result+"]";
  }
  //計(jì)算不帶括號的四則運(yùn)算
  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);
  }
  
  //計(jì)算帶括號的四則運(yùn)算
  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);
 }
 /**
  * 計(jì)算最小單位四則運(yùn)算表達(dá)式(兩個(gè)數(shù)字)
  * @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)){
   //第二個(gè)參數(shù)為精度,第三個(gè)為四色五入的模式
   result=number1.divide(number2,5,BigDecimal.ROUND_CEILING);
  }
  
  return result!=null?result.toString():null;
 }
 
}

代碼原本是一個(gè)博客,原來代碼沒有注釋而且存在BUG,我稍微修稿了一哈添加了注釋。在這里做個(gè)筆記,方便以后用

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

/**
 * 四則運(yùn)算表達(dá)式計(jì)算
 * @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);
 }
 /**
 * 解析計(jì)算四則運(yùn)算表達(dá)式,例: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+)?\\]))$";
 //最小表達(dá)式計(jì)算
 if(expression.matches(minExp)){
 String result=calculate(expression);
 
 return Double.parseDouble(result)>=0?result:"["+result+"]";
 }
 //計(jì)算不帶括號的四則運(yùn)算
 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);
 }
 //計(jì)算帶括號的四則運(yùn)算
 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);
 }
 /**
 * 計(jì)算最小單位四則運(yùn)算表達(dá)式(兩個(gè)數(shù)字)
 * @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;
 }
}

最后給大家分享一個(gè)網(wǎng)友的實(shí)現(xiàn)方法,個(gè)人感覺也很不錯(cuò)

import java.util.Stack; 
/** 
 * 利用棧,進(jìn)行四則運(yùn)算的類 
 * 用兩個(gè)棧來實(shí)現(xiàn)算符優(yōu)先,一個(gè)棧用來保存需要計(jì)算的數(shù)據(jù)numStack,一個(gè)用來保存計(jì)算優(yōu)先符priStack 
 * 
 * 基本算法實(shí)現(xiàn)思路為:用當(dāng)前取得的運(yùn)算符與priStack棧頂運(yùn)算符比較優(yōu)先級:若高于,則因?yàn)闀冗\(yùn)算,放入棧頂; 
 * 若等于,因?yàn)槌霈F(xiàn)在后面,所以會后計(jì)算,所以棧頂元素出棧,取出操作數(shù)運(yùn)算; 
 * 若小于,則同理,取出棧頂元素運(yùn)算,將結(jié)果入操作數(shù)棧。各個(gè)優(yōu)先級'(' > '*' = '/' > '+' = '-' > ')' 
 * 
 */  
public class Operate {  
 private Stack<Character> priStack = new Stack<Character>();// 操作符棧  
 private Stack<Integer> numStack = new Stack<Integer>();;// 操作數(shù)棧  
  
 /** 
  * 傳入需要解析的字符串,返回計(jì)算結(jié)果(此處因?yàn)闀r(shí)間問題,省略合法性驗(yàn)證) 
  * @param str 需要進(jìn)行技術(shù)的表達(dá)式 
  * @return 計(jì)算結(jié)果 
  */  
 public int caculate(String str) {  
  // 1.判斷string當(dāng)中有沒有非法字符  
  String temp;// 用來臨時(shí)存放讀取的字符  
  // 2.循環(huán)開始解析字符串,當(dāng)字符串解析完,且符號棧為空時(shí),則計(jì)算完成  
  StringBuffer tempNum = new StringBuffer();// 用來臨時(shí)存放數(shù)字字符串(當(dāng)為多位數(shù)時(shí))  
  StringBuffer string = new StringBuffer().append(str);// 用來保存,提高效率  
  
  while (string.length() != 0) {  
   temp = string.substring(0, 1);  
   string.delete(0, 1);  
   // 判斷temp,當(dāng)temp為操作符時(shí)  
   if (!isNum(temp)) {  
    // 1.此時(shí)的tempNum內(nèi)即為需要操作的數(shù),取出數(shù),壓棧,并且清空tempNum  
    if (!"".equals(tempNum.toString())) {  
     // 當(dāng)表達(dá)式的第一個(gè)符號為括號  
     int num = Integer.parseInt(tempNum.toString());  
     numStack.push(num); 
     tempNum.delete(0, tempNum.length());  
    }  
    // 用當(dāng)前取得的運(yùn)算符與棧頂運(yùn)算符比較優(yōu)先級:若高于,則因?yàn)闀冗\(yùn)算,放入棧頂;若等于,因?yàn)槌霈F(xiàn)在后面,所以會后計(jì)算,所以棧頂元素出棧,取出操作數(shù)運(yùn)算;  
    // 若小于,則同理,取出棧頂元素運(yùn)算,將結(jié)果入操作數(shù)棧。  
  
    // 判斷當(dāng)前運(yùn)算符與棧頂元素優(yōu)先級,取出元素,進(jìn)行計(jì)算(因?yàn)閮?yōu)先級可能小于棧頂元素,還小于第二個(gè)元素等等,需要用循環(huán)判斷)  
    while (!compare(temp.charAt(0)) && (!priStack.empty())) { 
     int a = (int) numStack.pop();// 第二個(gè)運(yùn)算數(shù)  
     int b = (int) numStack.pop();// 第一個(gè)運(yùn)算數(shù)  
     char ope = priStack.pop();  
     int result = 0;// 運(yùn)算結(jié)果  
     switch (ope) {  
     // 如果是加號或者減號,則  
     case '+':  
      result = b + a;  
      // 將操作結(jié)果放入操作數(shù)棧  
      numStack.push(result);  
      break;  
     case '-':  
      result = b - a;  
      // 將操作結(jié)果放入操作數(shù)棧  
      numStack.push(result);  
      break;  
     case '*':  
      result = b * a;  
      // 將操作結(jié)果放入操作數(shù)棧  
      numStack.push(result);  
      break;  
     case '/':  
      result = b / a;// 將操作結(jié)果放入操作數(shù)棧  
      numStack.push(result);  
      break;  
     }  
  
    }  
    // 判斷當(dāng)前運(yùn)算符與棧頂元素優(yōu)先級, 如果高,或者低于平,計(jì)算完后,將當(dāng)前操作符號,放入操作符棧  
    if (temp.charAt(0) != '#') {  
     priStack.push(new Character(temp.charAt(0)));  
     if (temp.charAt(0) == ')') {// 當(dāng)棧頂為'(',而當(dāng)前元素為')'時(shí),則是括號內(nèi)以算完,去掉括號  
      priStack.pop();  
      priStack.pop();  
     }  
    }  
   } else  
    // 當(dāng)為非操作符時(shí)(數(shù)字)  
    tempNum = tempNum.append(temp);// 將讀到的這一位數(shù)接到以讀出的數(shù)后(當(dāng)不是個(gè)位數(shù)的時(shí)候)  
  }  
  return numStack.pop();  
 }  
  
 /** 
  * 判斷傳入的字符是不是0-9的數(shù)字 
  * 
  * @param str 
  *   傳入的字符串 
  * @return 
  */  
 private boolean isNum(String temp) {  
  return temp.matches("[0-9]");  
 }  
  
 /** 
  * 比較當(dāng)前操作符與棧頂元素操作符優(yōu)先級,如果比棧頂元素優(yōu)先級高,則返回true,否則返回false 
  * 
  * @param str 需要進(jìn)行比較的字符 
  * @return 比較結(jié)果 true代表比棧頂元素優(yōu)先級高,false代表比棧頂元素優(yōu)先級低 
  */  
 private boolean compare(char str) {  
  if (priStack.empty()) {  
   // 當(dāng)為空時(shí),顯然 當(dāng)前優(yōu)先級最低,返回高  
   return true;  
  }  
  char last = (char) priStack.lastElement();  
  // 如果棧頂為'('顯然,優(yōu)先級最低,')'不可能為棧頂。  
  if (last == '(') {  
   return true;  
  }  
  switch (str) {  
  case '#':  
   return false;// 結(jié)束符  
  case '(':  
   // '('優(yōu)先級最高,顯然返回true  
   return true;  
  case ')':  
   // ')'優(yōu)先級最低,  
   return false;  
  case '*': {  
   // '*/'優(yōu)先級只比'+-'高  
   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);  
 }  
  
}  

相關(guān)文章

  • spring boot 2整合swagger-ui過程解析

    spring boot 2整合swagger-ui過程解析

    這篇文章主要介紹了spring boot 2整合swagger-ui過程解析,文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下
    2019-12-12
  • IDEA新建bootstrap.yml文件不顯示葉子圖標(biāo)的問題

    IDEA新建bootstrap.yml文件不顯示葉子圖標(biāo)的問題

    這篇文章主要介紹了IDEA新建bootstrap.yml文件不顯示葉子圖標(biāo)的問題及解決方案,具有很好的參考價(jià)值,希望對大家有所幫助。如有錯(cuò)誤或未考慮完全的地方,望不吝賜教
    2023-07-07
  • java泛型基本知識及通用方法

    java泛型基本知識及通用方法

    這篇文章主要介紹了java泛型基礎(chǔ)知識及通用方法,從以下幾個(gè)方面介紹一下java的泛型: 基礎(chǔ), 泛型關(guān)鍵字, 泛型方法, 泛型類和接口,感興趣的可以了解一下
    2019-04-04
  • MyBatis-Plus使用ActiveRecord(AR)實(shí)現(xiàn)CRUD

    MyBatis-Plus使用ActiveRecord(AR)實(shí)現(xiàn)CRUD

    本文將結(jié)合實(shí)例代碼,介紹MyBatis-Plus使用ActiveRecord(AR)實(shí)現(xiàn)CRUD,文中通過示例代碼介紹的非常詳細(xì),需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧
    2021-07-07
  • 淺談Java數(shù)據(jù)結(jié)構(gòu)之稀疏數(shù)組知識總結(jié)

    淺談Java數(shù)據(jù)結(jié)構(gòu)之稀疏數(shù)組知識總結(jié)

    今天帶大家了解一下Java稀疏數(shù)組的相關(guān)知識,文中有非常詳細(xì)的介紹及代碼示例,對正在學(xué)習(xí)java的小伙伴們有很好地幫助,需要的朋友可以參考下
    2021-05-05
  • Java8如何構(gòu)建一個(gè)Stream示例詳解

    Java8如何構(gòu)建一個(gè)Stream示例詳解

    Java 8 是迄今為止在語義上改動上最大的一個(gè)平臺。下面這篇文章主要給大家介紹了關(guān)于Java8如何構(gòu)建一個(gè)Stream的相關(guān)資料,文中通過示例代碼介紹的非常詳細(xì),需要的朋友可以參考借鑒,下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧。
    2018-04-04
  • JPA @Query時(shí),無法使用limit函數(shù)的問題及解決

    JPA @Query時(shí),無法使用limit函數(shù)的問題及解決

    這篇文章主要介紹了JPA @Query時(shí),無法使用limit函數(shù)的問題及解決方案,具有很好的參考價(jià)值,希望對大家有所幫助。如有錯(cuò)誤或未考慮完全的地方,望不吝賜教
    2022-03-03
  • RocketMQ的消費(fèi)者類型與最佳實(shí)踐詳解

    RocketMQ的消費(fèi)者類型與最佳實(shí)踐詳解

    這篇文章主要介紹了RocketMQ的消費(fèi)者類型與最佳實(shí)踐詳解,在?RocketMQ?5.0?中,更加強(qiáng)調(diào)了客戶端類型的概念,尤其是消費(fèi)者類型,為了滿足多樣的?RocketMQ?中一共有三種不同的消費(fèi)者類型,分別是?PushConsumer、SimpleConsumer?和?PullConsumer,需要的朋友可以參考下
    2023-10-10
  • java的finalize方法解讀

    java的finalize方法解讀

    這篇文章主要介紹了java的finalize方法,具有很好的參考價(jià)值,希望對大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教
    2023-09-09
  • Java mockito單元測試實(shí)現(xiàn)過程解析

    Java mockito單元測試實(shí)現(xiàn)過程解析

    這篇文章主要介紹了Java mockito單元測試實(shí)現(xiàn)過程解析,文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下
    2020-08-08

最新評論