java字符串應用之表達式解析器

時間  2019-12-20
標籤 java 字符串 應用 表達式 解析 欄目 Java 简体版
原文   原文鏈接

 1、表達式的組成
    一、數字
    二、運算符：+ - / * ^ % =
    三、圓括號
    四、變量
2、運算符優先級
    由高到低分別爲：+-(正負號)、^、*/%、+-、=
    優先級相等的運算符按照從左到右的順序計算
3、關鍵技術點
    一、肯定運算的優先級，從高到低分別爲：原子元素表達式，包括數字和變量；括號表達式；一元表達式，取數的負數；指數表達式；乘、除、取模表達式；加、減表達式；賦值表達式。
    二、對於每一級別的運算，都由一個方法實現，在方法中先完成比本身高一級別的運算，再處理本級別的運算。所以，在計算整個表達式的主方法中，只須要調用最低級別的運算的實現方法便可。
    三、肯定表達式中的分隔符，（+、-、*、/、%、^、=、(、)、）。利用這些分隔符將表達式分紅多段，每一段叫作一個token，分隔符也算token。
    四、用長度爲26的int數組vars存儲變量的值。
    五、Character的isWhitespace方法判斷字符是否爲空白符，用於去掉表達式中的空白符。
    六、Character的isLetter方法判斷字符是否爲字母，用於提取表達式中的變量
    七、Character的isDigit方法判斷字符是否爲數字，用於獲取表達式中的數字
    
4、演示實例html

 

 

/** *//**
 * 文件名ExpressionParser.java
 */
package book.oo.String;java

/** *//**
 * 表達式解析器
 * @author joe
 *
 */
public class ExpressionParser ...{
    //4種標記類型
    public static final int NONE_TOKEN = 0;    //標記爲空或者結束符
    public static final int DELIMITER_TOKEN = 1;    //標記爲分隔符
    public static final int VARIABLE_TOKEN = 2;    //標記爲變量
    public static final int NUMBER_TOKEN = 3;    //標記爲數字
    
    //4種錯誤類型
    public static final int SYNTAX_ERROR = 0;    //語法錯誤
    public static final int UNBALPARENS_ERROR = 1;    //括號沒有結束錯誤
    public static final int NOEXP_ERROR = 2;    //表達式爲空錯誤
    public static final int DIVBYZERO_ERROR = 3;    //被0除錯誤
    
    //針對4種錯誤類型定義的4個錯誤提示
    public static final String[] ERROR_MESSAGES = ...{"Syntax Error", "Unbalanced " +
            "Parentheses", "No Expression Present", "Division by Zero"};
    
    //表達式的結束標記
    public static final String EOE = ""/0";
 
 private String exp; //表達式字符串
 private int expIndex; //解析器當前指針在表達式中的位置
 private String token; //解析器當前處理的標記
 private int tokenType; //解析器當前處理的標記類型
 private double[] vars = new double[26]; //變量數組
 /**
  * 
  */
 public ExpressionParser() {
 }
 
 /**
  * 解析一個表達式，返回表達式的值
  */
 public double evaluate(String expStr) throws Exception {
  double result;
  this.exp = expStr;
  this.expIndex = 0;
  
  //獲取第一個標記
  this.getToken();
  if (this.token.equals(EOE)) {
   //沒有表達式異常
   this.handleError(NOEXP_ERROR);
  }
  
  result = this.parseAssign(); //處理賦值語句
  //處理完賦值語句，應該就是表達式結束符，若是不是，則返回異常
  if(!this.token.equals(EOE)) {
   this.handleError(SYNTAX_ERROR);
  }
  return result;
 }
 
 /**
  * 處理賦值語句
  */
 public double parseAssign() throws Exception {
  double result; //結果
  int varIndex; //變量下標
  String oldToken; //舊標記
  int oldTokenType; //舊標記的類型
  
  //若是標記類型是變量
  if (this.tokenType == VARIABLE_TOKEN) {
   //保存當前標記
   oldToken = new String(this.token);
   oldTokenType = this.tokenType;
   //取得變量的索引，本解析器只支持一個字母的變量
   //若是用戶的變量字母長度大於1，則取第一個字母看成變量
   varIndex = Character.toUpperCase(this.token.charAt(0)) - ''A'';
   
   //得到下一個標記
   this.getToken();
   //若是當前標記不是等號＝
   if(!this.token.equals("=")) {
    this.putBack(); //回滾
    //不是一個賦值語句，將標記恢復到上一個標記
    this.token = new String(oldToken);
    this.tokenType = oldTokenType;
   } else {
    //若是當前標記是等號＝，即給變量賦值，形式如：a = 3 + 5;
    //則計算等號後面表達式的值，而後再將獲得的值賦給變量
    this.getToken();
    //由於加減法的優先級最低，因此計算加減法表達式
    result = this.parseAddOrSub();
    //將表達式的值賦給變量，並存在實例變量vars中
    this.vars[varIndex] = result;
    return result;
   }
  }
  //若是當前標記類型不是變量，或者不是賦值語句，則用加減法計算表達式的值
  return this.parseAddOrSub();
 }
 
 /** 計算加減法表達式 */
 private double parseAddOrSub() throws Exception {
  char op; //運算符
  double result; //結果
  double partialResult; //子表達式的結果
  
  result = this.pareseMulOrDiv(); //用乘除法計算當前表達式的值
  //若是當前標記的第一個字母是加減號，則繼續進行加減運算
  while ((op = this.token.charAt(0)) == ''+'' || op == ''-'') {
   this.getToken(); //取下一個標記
   //用乘除法計算當前子表達式的值
   partialResult = this.pareseMulOrDiv();
   switch(op) {
   case ''-'':
    //若是是減法，則用已處理的子表達式的值減去當前子表達式的值
    result = result - partialResult;
    break;
   case ''+'':
    //若是是加法，用已處理的子表達式的值加上當前子表達式的值
    result = result + partialResult;
    break;
   }
  }
  return result;
 }
 /**
  * 計算乘除法表達式，包括取模運算
  */
 private double pareseMulOrDiv() throws Exception {
  char op; //運算符
  double result; //結果
  double partialResult; //子表達式結果
  //用指數運算計算當前子表達式的值
  result = this.parseExponent();
  //若是當前標記的第一個字母是乘、除或者取模運算，則繼續進行乘除法運算
  while ((op = this.token.charAt(0)) == ''*'' || op == ''/'' || op == ''%'') {
   this.getToken(); //取下一標記
   //用指數運算計算當前子表達式的值
   partialResult = this.parseExponent();
   switch (op) {
   case ''*'':
    //若是是乘法，則用已處理子表達式的值乘以當前子表達式的值
    result = result * partialResult;
    break;
   case ''/'':
    //若是是除法，判斷當前字表達式的值是否爲0，若是爲0，則拋出被0除異常
    if(partialResult == 0.0) {
     this.handleError(DIVBYZERO_ERROR);
    }
    //除數不爲0，則進行除法運算
    result = result / partialResult;
    break;
   case ''%'':
    //若是是取模運算，也要判斷當前子表達式的值是否爲0
    if(partialResult == 0.0) {
     this.handleError(DIVBYZERO_ERROR);
    }
    result = result % partialResult;
    break;
   }
  }
  return result;
 }
 
 /**
  * 計算指數表達式
  */
 private double parseExponent() throws Exception {
  double result; //結果
  double partialResult; //子表達式的值
  double ex; //指數的底數
  int t; //指數的冪
  
  //用一元運算計算當前子表達式的值（底數）
  result = this.parseUnaryOperator();
  //若是當前標記爲「^」,則爲指數運算
  if (this.token.equals("^")) {
   //獲取下一標記，即得到指數的冪
   this.getToken();
   partialResult = this.parseExponent();
   ex = result;
   if(partialResult == 0.0) {
    //若是指數的冪爲0，則指數的值爲1
    result = 1.0;
   } else {
    //不然，指數的值爲個數爲指數冪的底數相乘的結果
    for (t = (int) partialResult - 1; t > 0; t--) {
     result =result * ex;
    }
   }
  }
  return result;
 }
 
 /**
  * 計算一元運算，＋，－，表示正數和負數 
  */
 private double parseUnaryOperator() throws Exception{
  double result; //結果
  String op; //運算符
  op = "";
  //若是當前標記類型爲分隔符，並且分隔符的值等於+或者-
  if((this.tokenType == DELIMITER_TOKEN) && this.token.equals("+") || this.token.equals("-")) {
   op = this.token;
   this.getToken();
  }
  //用括號運算計算當前子表達式的值
  result = this.parseBracket();
  if(op.equals("-")) {
   //若是運算符爲-，則表示負數，將子表達式的值變爲負數
   result = -result;
  }
  return result;
 }
 
 /**
  * 計算括號運算
  */
 private double parseBracket() throws Exception {
  double result; //結果
  //若是當前標記爲左括號，則表示是一個括號運算
  if (this.token.equals("(")) {
   this.getToken(); //取下一標記
   result = this.parseAddOrSub(); //用加減法運算計算子表達式的值
   //若是當前標記不等於右括號，拋出括號不匹配異常
   if (!this.token.equals(")")) {
    this.handleError(UNBALPARENS_ERROR);
   }
   this.getToken(); //不然取下一個標記
  } else {
   //若是不是左括號，表示不是一個括號運算，則用原子元素運算計算子表達式值
   result = this.parseAtomElement();
  }
  return result;
 }
 
 /**
  * 計算原子元素運算，包括變量和數字 
  */
 private double parseAtomElement() throws Exception {
  double result = 0.0; //結果
  
  switch(this.tokenType) {
  case NUMBER_TOKEN:
   //若是當前標記類型爲數字
   try {
    //將數字的字符串轉換成數字值
    result = Double.parseDouble(this.token);
   } catch (NumberFormatException exc) {
    this.handleError(SYNTAX_ERROR);
   }
   this.getToken(); //取下一個標記
   break;
  case VARIABLE_TOKEN:
   //若是當前標記類型是變量，則取變量的值
   result = this.findVar(token);
   this.getToken();
   break;
  default:
   this.handleError(SYNTAX_ERROR);
   break;
  }
  return result;
 }
 
 /**
  * 根據變量名獲取變量的值，若是變量名長度大於1，則只取變量的第一個字符 
  */
 private double findVar(String vname) throws Exception {
  if (!Character.isLetter(vname.charAt(0))) {
   this.handleError(SYNTAX_ERROR);
   return 0.0;
  }
  //從實例變量數組vars中取出該變量的值
  return vars[Character.toUpperCase(vname.charAt(0)) - ''A''];
 }
 
 /** 
  * 回滾，將解析器當前指針往前移到當前標記位置
  */
 private void putBack() {
  if (this.token == EOE) {
   return;
  }
  //解析器當前指針往前移動
  for (int i = 0; i < this.token.length(); i++ ){
   this.expIndex--;
  }
 }
 
 /**
  * 處理異常狀況
  */
 private void handleError(int errorType) throws Exception {
  //遇到異常狀況時，根據錯誤類型，取得異常提示信息，將提示信息封裝在異常中拋出
  throw new Exception(ERROR_MESSAGES[errorType]);
 }
 
 /**
  * 獲取下一個標記
  */
 private void getToken() {
  //設置初始值
  this.token = "";
  this.tokenType = NONE_TOKEN;
  
  //檢查表達式是否結束，若是解析器當前指針已經到達了字符串長度，
  //則代表表達式已經結束，置當前標記的值爲EOE
  if(this.expIndex == this.exp.length()) {
   this.token = EOE;
   return;
  }
  
  //跳過表達式中的空白符
  while (this.expIndex < this.exp.length() 
    && Character.isWhitespace(this.exp.charAt(this.expIndex))) {
   ++this.expIndex;
  }
  
  //再次檢查表達式是否結束
  if (this.expIndex == this.exp.length()) {
   this.token = EOE;
   return;
  }
  
  //取得解析器當前指針指向的字符
  char currentChar = this.exp.charAt(this.expIndex);
  //若是當前字符是一個分隔符，則認爲這是一個分隔符標記
  //給當前標記和標記類型賦值，並將指針後移
  if(isDelim(currentChar)) {
   this.token += currentChar;
   this.expIndex++;
   this.tokenType = DELIMITER_TOKEN;
  } else if (Character.isLetter(currentChar)) {
   //若是當前字符是一個字母，則認爲是一個變量標記
   //將解析器指針日後移，知道遇到一個分隔符，之間的字符都是變量的組成部分
   while(!isDelim(currentChar)) {
    this.token += currentChar;
    this.expIndex++;
    if(this.expIndex >= this.exp.length()) {
     break;
    } else {
     currentChar = this.exp.charAt(this.expIndex);
    }
   }
   this.tokenType = VARIABLE_TOKEN; //設置標記類型爲變量
  } else if (Character.isDigit(currentChar)) {
   //若是當前字符是一個數字，則認爲當前標記的類型爲數字
   //將解析器指針後移，知道遇到一個分隔符，之間的字符都是該數字的組成部分
   while(!isDelim(currentChar)) {
    this.token += currentChar;
    this.expIndex++;
    if (this.expIndex >= this.exp.length()) {
     break;
    } else {
     currentChar = this.exp.charAt(this.expIndex);
    }
   }
   this.tokenType = NUMBER_TOKEN; //設置標記類型爲數字
  } else {
   //沒法識別的字符，則認爲表達式結束
   this.token = EOE;
   return;
  }
 }
 
 /**
  * 判斷一個字符是否爲分隔符
  * 表達式中的字符包括：
  * 加「＋」、減「－」、乘「*」、除「/」、取模「%」、指數「^」、賦值「＝」、左括號「（」、右括號「）」
  */
 private boolean isDelim(char c) {
  if (("+-*/%^=()".indexOf(c) != -1))
   return true;
  return false;
 }
 /**
  * @param args
  */
 public static void main(String[] args) throws Exception{
  ExpressionParser test = new ExpressionParser();
  
  String exp1 = "a = 5.0";
  System.out.println("exp1(/"a = 5.0/") = " + test.evaluate(exp1));
  
  String exp2 = "b = 3.0";
  System.out.println("exp2(/"b = 3.0/") = " + test.evaluate(exp2));
  
  String exp3 = "(a + b) * (a - b)";
  System.out.println("exp3(/"(a + b) * (a - b)/") = " + test.evaluate(exp3));
  
  String exp4 = "3*5-4/2";
  System.out.println("exp4(/"3*5-4/2/") = " + test.evaluate(exp4));
  
  String exp5 = "(4-2) * ((a + b) / (a - b))";
  System.out.println("exp5(/"(4 - 2) * ((a + b) / (a - b))/") = " + test.evaluate(exp5));
  
  String exp6 = "5 % 2";
  System.out.println("exp6(/"5 % 2/") = " + test.evaluate(exp6));
  
  String exp7 = "3^2 * 5 + 4";
  System.out.println("exp7(/"3^2 * 5 + 4/") = " + test.evaluate(exp7));
 }
}
 git

輸出結果：數組

exp1("a = 5.0") = 5.0
exp2("b = 3.0") = 3.0
exp3("(a + b) * (a - b)") = 16.0
exp4("3*5-4/2") = 13.0
exp5("(4 - 2) * ((a + b) / (a - b))") = 8.0
exp6("5 % 2") = 1.0
exp7("3^2 * 5 + 4") = 49.0this

5、實例分析
    表達式的解析，實際就是一個表達式的分解過程。根據分隔符將表達式分紅若干段。而後計算每一段的值，最後都會歸結到一個原子表達式。lua


文章出處：http://www.diybl.com/course/3_program/java/javaxl/20071126/87573.htmlspa

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程