Go语言视频零基础入门到精通

javalearner

对于未经训练的用户来说，计算机科学领域中数学表达式求值的传统方法即不顺手又难以使用；软件工程师 Nikola.Stepan 旨在改变这些传统方法。他的 applet W3Eval 对表达式求值与您用纸笔计算的一系列步骤完全一致，但更快并且没有错误。请往下读，了解这一挑战 � 人类易读的数学到 java 代码的转换。
        还记得在您的第一台科学计算器上用逆波兰表示法奋斗的经历吗？W3Eval applet 无法让您可信赖的 HP-41 更易用，正如它的名称所暗示 � 一个只能运行于 Web 的表达式求值程序。但它的确提供了一种方法 � 人类更易于遵循的对表达式一步一步的求值。
         W3Eval 的方法与传统计算器不同，却和人类的计算方式一致。当您用传统的计算器计算时，每输入一个新数，前一个数就看不到了。如果在输入一个长表达式中出了错，就得全部重来。有了 W3Eval，您就能看到参与计算的所有东西，还能轻松的编辑表达式。它独特的能力（一步一步的对表达式求值）非常容易实现，因为用户能看到求值的每一步，包括临时结果。
         本文将让您从头至尾认识 W3Eval 功能性的要点；您将看到一些用于表达式求值的代码。不过，我们还是先看看表达式求值的经典算法，这样您就会明白 W3Eval 方法的差异究竟有多少。
   
applet W3Eval的运行界面：
  
   
  
   
   
   

   
  
  
  
   
  
    表达式求值的经典算法 编写代码对算术表达式求值的经典方法由 Donald Knuth 描述于 1962 年。Knuth 将此概括为三个步骤：  

对中缀表达式进行语法分析
中缀表达式到后缀表达式的转换
对后缀表达式求值  
注意到我们谈到的这个经典算法有些简化：算术表达式只包含操作数、二元操作符和一种括号。此外，对于每个操作数和操作符，只用单个字符表示，使语法分析直观。 表达式表示法 算术表达式中最常见的表示法形式有 中缀、前缀和 后缀表示法。中缀表示法是书写表达式的常见方式，而前缀和后缀表示法主要用于计算机科学领域。  中缀表示法
中缀表示法是算术表达式的常规表示法。称它为 中缀表示法是因为每个操作符都位于其操作数的中间，这种表示法只适用于操作符恰好对应两个操作数的时候（在操作符是二元操作符如加、减、乘、除以及取模的情况下）。对以中缀表示法书写的表达式进行语法分析时，需要用括号和优先规则排除多义性。  

  
   
  

1. 
   
2. Syntax: operand1 operator operand2
   
3. Example: (A+B)*C-D/(E+F)
   

复制代码

[/code]
   
  

前缀表示法
前缀表示法中，操作符写在操作数的前面。这种表示法经常用于计算机科学，特别是编译器设计方面。为纪念其发明家 � Jan Lukasiewicz，这种表示法也称 波兰表示法。  

  
   
  

1. 
   
2. Syntax  : operator operand1 operand2
   
3. Example : -*+ABC/D+EF
   

复制代码

[/code]
   
  

后缀表示法
在后缀表示法中，操作符位于操作数后面。后缀表示法也称 逆波兰表示法（reverse Polish notation，RPN），因其使表达式求值变得轻松，所以被普遍使用。  

  
   
  

1. 
   
2. Syntax  : operand1 operand2 operator
   
3. Example : AB+C*DEF+/-
   

复制代码

[/code]
   
  

前缀和后缀表示法有三项公共特征：

操作数的顺序与等价的中缀表达式中操作数的顺序一致
不需要括号
操作符的优先级不相关  
中缀表达式到后缀表达式的转换 要把表达式从中缀表达式的形式转换成用后缀表示法表示的等价表达式，必须了解操作符的优先级和结合性。 优先级或者说操作符的强度决定求值顺序；优先级高的操作符比优先级低的操作符先求值。 如果所有操作符优先级一样，那么求值顺序就取决于它们的 结合性。操作符的结合性定义了相同优先级操作符组合的顺序（从右至左或从左至右）。  

  
   
  

1. 
   
2. Left associativity  : A+B+C = (A+B)+C
   
3. Right associativity : A^B^C = A^(B^C)
   

复制代码

[/code]
   
  

转换过程包括用下面的算法读入中缀表达式的操作数、操作符和括号：

初始化一个空堆栈，将结果字符串变量置空。
从左到右读入中缀表达式，每次一个字符。
如果字符是操作数，将它添加到结果字符串。
如果字符是个操作符，弹出（pop）操作符，直至遇见开括号（opening parenthesis）、优先级较低的操作符或者同一优先级的右结合符号。把这个操作符压入（push）堆栈。
如果字符是个开括号，把它压入堆栈。
如果字符是个闭括号（closing parenthesis），在遇见开括号前，弹出所有操作符，然后把它们添加到结果字符串。
如果到达输入字符串的末尾，弹出所有操作符并添加到结果字符串。  
后缀表达式求值 对后缀表达式求值比直接对中缀表达式求值简单。在后缀表达式中，不需要括号，而且操作符的优先级也不再起作用了。您可以用如下算法对后缀表达式求值：

初始化一个空堆栈
从左到右读入后缀表达式
如果字符是一个操作数，把它压入堆栈。
如果字符是个操作符，弹出两个操作数，执行恰当操作，然后把结果压入堆栈。如果您不能够弹出两个操作数，后缀表达式的语法就不正确。
到后缀表达式末尾，从堆栈中弹出结果。若后缀表达式格式正确，那么堆栈应该为空。  



  
   
   
   
  


W3Eval：一种新的方法 W3Eval 的方法与上面概括的经典算法不同。不是把中缀表达式转换为后缀表示法；恰恰相反，它对中缀表达式直接求值。这种方法比传统方法稍微复杂了些，但它支持一步一步的求值，在执行时您能看到每一步。求值过程类似于手工计算：如果表达式中包含括号，先求嵌套最深的括号对中的子表达式的值。所有括号内的子表达式都求值完毕后，表达式的其它部分再求值。 求值过程分为三个步骤：

表达式语法分析
表达式检查
一步一步的求值  
表达式语法分析 W3Eval 的数学表达式由数字、变量、操作符、函数和括号组成。除了缺省的十进制计数制外 W3Eval 还支持二进制、八进制和十六进制。这些以其它计数制计数的数必须以

1. #

复制代码

开头，并紧跟

1. b

复制代码

、

1. o

复制代码

或者

1. h

复制代码

来分别表示二进制、八进制或十六进制。  W3Eval 的变量是不限长度的大写字母和数字序列，其首字符必须是字母。W3Eval 有一些预定义的变量，不过它也支持用户定义的变量。 W3Eval 支持带有固定或不定数量自变量的函数。 函数可分为以下几组：

三角函数（sin、cos、tan、cot、sec、csc）
反三角函数（asin、acos、atan、atan2、acot、asec、acsc）
双曲线函数（sinh、cosh、tanh、coth、sech、csch）
反双曲线函数（asinh、acosh、atanh、acoth、asech、acsch）
指数函数（log、log2、log10、exp、exp2、exp10、sqrt、cur）
组合学函数（Combinatoric）（comb、combr、perm、permr、var、varr）
统计函数（sum、avg、min、max、stddev、count）
其它（abs、ceil、fact、floor、pow、random、rint、round、sign、frac、hypot、deg、rad、trunc、int）  
W3Eval 对表达式进行 语法分析，也就是指它识别出表达式的算术成分，并将它们转化成语言符号（token），然后把它们放入向量。表达式一旦处于这种状态，就为下面两步做好了准备：表达式检查和求值。  W3Eval 的 符号（token）是算术表达式的组成部分； 记号（mark）是独立的字符， 由 applet 使用，作为识别各种符号的内部标志。每种符号有唯一的 mark 与之对应。W3Eval 的表达式由表 1 所示的符号组成。  表 1. W3Eval 的符号  

  
   
   Token  
   Mark  
   类  
   
   
   十进制数
   
  

1. Double

复制代码

   
   
   二进制数
   
  

1. String

复制代码

   
   
   十六进制数
   
  

1. String

复制代码

   
   
   八进制数
   
  

1. String

复制代码

   
   
   变量
   
   Variable
   
   
   函数
   
  

1. Function

复制代码

   
   
   操作符
   
  

1. Operator

复制代码

   
   
   开括号
   
  

1. String

复制代码

   
   
   闭括号
   
  

1. String

复制代码

   
   
   逗号
   
  

1. String

复制代码

   
  
  用以表示函数、操作符和变量类的定义如清单 1 所示：
清单 1. Function、Operator 和 Variable 类的定义


  
   
  

1. 
   
2. public class Function
   
3.    {
   
4.    public String function;
   
5.    public int number_of_arguments;
   
6.    public Function( String function, int number_of_arguments )
   
7.       {
   
8.       this.function=function;
   
9.       this.number_of_arguments=number_of_arguments;
   
10.       }
    
11.    public String toString()
    
12.       {
    
13.       return function;
    
14.       }
    
15.    }
    
16. public class Operator
    
17.    {
    
18.    public String operator;
    
19.    public byte priority;
    
20.    public Operator( String operator, byte priority )
    
21.       {
    
22.       this.operator=operator;
    
23.       this.priority=priority;
    
24.       }
    
25.    public String toString()
    
26.       {
    
27.       return operator;
    
28.       }
    
29.    }
    
30. public class Variable
    
31.    {
    
32.    public String variable;
    
33.    public double value;
    
34.    public Variable( String variable, double value )
    
35.       {
    
36.       this.variable=variable;
    
37.       this.value=value;
    
38.       }
    
39.    public String toString()
    
40.       {
    
41.       return variable;
    
42.       }
    
43.    }
    

复制代码

[/code]
   
  

1. Token

复制代码

类如清单 2 所示。  
清单 2. Token 类


  
   
  

1. 
   
2. public class Token
   
3.    {
   
4.    public Object token;
   
5.    public char mark;
   
6.    public int position;
   
7.    public int length;
   
8.    public Token ( Object token, char mark, int position, int length )
   
9.       {
   
10.       this.token=token;
    
11.       this.mark=mark;
    
12.       this.position=position;
    
13.       this.length=length;
    
14.       }
    
15.    public String toString()
    
16.       {
    
17.       return token.toString()+" ; "+mark+" ; "+position+" ; "+length+"
    
18. ";
    
19.       }
    
20.    }
    

复制代码

[/code]
   
  

表达式检查 检查正规表达式正确性的所有代码都在一个独立的类中。详细的表达式检查能够确定错误确切的类型和位置。 错误检查有七类： 括号检查。W3Eval 的表达式可以包含三种括号：标准圆括号、方括号和花括号。如果表达式包含相同数量的开括号和闭括号，并且每个开括号与一个相应的同种闭括号相匹配，则表达式的括号语法正确。三种括号在语义上等价，如下面的代码段所示。  
清单 3. 三种括号


  
   
  

1. 
   
2. import java.util.Stack;
   
3. public class Parentheses_check
   
4.    {
   
5.    public static boolean is_open_parenthesis( char c )
   
6.       {
   
7.       if ( c=="(" || c=="[" || c=="{" )
   
8.          return true;
   
9.       else
   
10.          return false;
    
11.       }
    
12.    public static boolean is_closed_parenthesis( char c )
    
13.       {
    
14.       if ( c==")" || c=="]" || c=="}" )
    
15.          return true;
    
16.       else
    
17.          return false;
    
18.       }
    
19.    private static boolean parentheses_match( char open, char closed )
    
20.       {
    
21.       if ( open=="(" && closed==")" )
    
22.          return true;
    
23.       else if ( open=="[" && closed=="]" )
    
24.          return true;
    
25.       else if ( open=="{" && closed=="}" )
    
26.          return true;
    
27.       else
    
28.          return false;
    
29.       }
    
30.    public static boolean parentheses_valid( String exp )
    
31.       {
    
32.       Stack       s = new Stack();
    
33.       int         i;
    
34.       char        current_char;
    
35.       Character   c;
    
36.       char        c1;
    
37.       boolean     ret=true;
    
38.       for ( i=0; i < exp.length(); i++ )
    
39.          {
    
40.          current_char=exp.charAt( i );
    
41.          if ( is_open_parenthesis( current_char ) )
    
42.             {
    
43.             c=new Character( current_char );
    
44.             s.push( c );
    
45.             }
    
46.          else if ( is_closed_parenthesis( current_char ) )
    
47.             {
    
48.             if ( s.isEmpty() )
    
49.                {
    
50.                ret=false;
    
51.                break;
    
52.                }
    
53.             else
    
54.                {
    
55.                c=(Character)s.pop();
    
56.                c1=c.charValue();
    
57.                if ( !parentheses_match( c1, current_char ) )
    
58.                   {
    
59.                   ret=false;
    
60.                   break;
    
61.                   }
    
62.                }
    
63.             }
    
64.          }
    
65.       if ( !s.isEmpty() )
    
66.          ret=false;
    
67.       return ret;
    
68.       }
    
69.    }
    

复制代码

[/code]
   
  

token 检查。检查表达式语法。确保表达式所有部分都被认为是合法的。  表达式开头的检查（请参阅 清单 4） 。确保表达式从合法的符号开始。不可以用操作符、逗号或闭括号作为表达式的开始符。  
清单 4. 正确的表达式开头的检查


  
   
  

1. 
   
2. private static boolean begin_check( Vector tokens, Range r, StringBuffer err )
   
3.    {
   
4.    char     mark;
   
5.    Token    t;
   
6.    t=(Token)tokens.elementAt( 0 );
   
7.    mark=t.mark;
   
8.    if ( mark=="P" )
   
9.       err.append( Messages.begin_operator );
   
10.    else if ( mark==")" )
    
11.       err.append( Messages.begin_parenthesis );
    
12.    else if ( mark=="Z" )
    
13.       err.append ( Messages.begin_comma );
    
14.    else
    
15.       return true;
    
16.    r.start=0;
    
17.    r.end=t.length;
    
18.    return false;
    
19.    }
    

复制代码

[/code]
   
  

表达式末尾的检查。确保表达式以合法符号结束。不可以用操作符、函数、逗号或开括号作为表达式结束符。  符号序列的检查。检查表达式中的符号序列。在下面的表格中，若 X 轴上的符号和 Y 轴上的符号对应的交界处用 X 作了记号，则相应 X 轴上的符号可以接在 Y 轴上符号的后面。  表 2. 合法的符号序列  

  
   
   
  
   
   _  
   D  
   B  
   H  
   O  
   V  
   F  
   P  
   (  
   )  
   Z  
   
   
   D  
   _
   _
   _
   _
   _
   _
   &#65533;
   _
   &#65533;
   &#65533;
   
   
   B  
   _
   _
   _
   _
   _
   _
   &#65533;
   _
   &#65533;
   &#65533;
   
   
   H  
   _
   _
   _
   _
   _
   _
   &#65533;
   _
   &#65533;
   &#65533;
   
   
   O  
   _
   _
   _
   _
   _
   _
   &#65533;
   _
   &#65533;
   &#65533;
   
   
   V  
   _
   _
   _
   _
   _
   _
   &#65533;
   _
   &#65533;
   &#65533;
   
   
   F  
   _
   _
   _
   _
   _
   _
   _
   &#65533;
   _
   _
   
   
   P  
   &#65533;
   &#65533;
   &#65533;
   &#65533;
   &#65533;
   &#65533;
   _
   &#65533;
   _
   _
   
   
   (  
   &#65533;
   &#65533;
   &#65533;
   &#65533;
   &#65533;
   &#65533;
   _
   &#65533;
   _
   _
   
   
   )  
   _
   _
   _
   _
   _
   _
   &#65533;
   _
   &#65533;
   &#65533;
   
   
   Z  
   &#65533;
   &#65533;
   &#65533;
   &#65533;
   &#65533;
   &#65533;
   _
   &#65533;
   _
   _
   
  
  函数检查。确保表达式中所有函数的自变量数量正确。  逗号检查。逗号只能用于分隔函数的自变量。若用于表达式其它地方，就不合法。  一步一步的求值 只有能顺利通过以上概括的所有检查的表达式，W3Eval 才求值。从而确保内建于 W3Eval 中的前提条件不会出现问题。后面的算法用于单步执行表达式求值：

找出嵌入最深的那对括号。
在这对括号中，找出优先级最高的操作符。
若这对括号中没有操作符：
   
   如果表达式再不包含任何其它的括号，求值（过程）完成。
   如果表达式包含括号，但不包含操作符，则存在一个函数。对函数求值，然后转到步骤 5。  
   
获取操作数并执行运算。
从向量中除去用过的符号并在同一位置放入结果。
除去冗余括号。
将向量中剩余的符号结合到字符串并在屏幕上显示结果。  
现在，我们将更为详细的查看算法的每一步，同时查看大部分有意思的代码片段。 步骤 1：为避免括号的处理，W3Eval 确定哪个子表达式处于嵌套最深的那对括号中。这项任务需要两步。第一步，W3Eval 必须找出第一个闭括号：  
清单 5. 找出第一个闭括号


  
   
  

1. 
   
2. public static int pos_first_closed_parenthesis( Vector tokens )
   
3.    {
   
4.    Token   t;
   
5.    for ( int i=0; i<tokens.size(); i++ )
   
6.       {
   
7.       t=(Token)tokens.elementAt( i );
   
8.       if ( t.mark==")" )
   
9.          return i;
   
10.       }
    
11.    return 0;
    
12.    }
    

复制代码

[/code]
   
  

第二步，找出与第一步找到的闭括号相匹配的开括号，如 清单 6 所示。  
清单 6. 找出匹配的开括号


  
   
  

1. 
   
2. public static int pos_open_parenthesis( Vector tokens, int closed_parenthesis )
   
3.    {
   
4.    int      i;
   
5.    Token    t;
   
6.    i=closed_parenthesis-2;
   
7.    while ( i>=0 )
   
8.       {
   
9.       t=(Token)tokens.elementAt( i );
   
10.       if ( t.mark=="(" )
    
11.          {
    
12.          return i;
    
13.          }
    
14.       i--;
    
15.       }
    
16.    return 0;
    
17.    }
    

复制代码

[/code]
   
  

步骤 2：要实现求值的单步执行，W3Eval 在嵌套最深的那对括号中找出优先级最高的操作符。（操作符的优先级已硬编码到 applet 中；请参阅 参考资料以获取完整的代码清单。）  
清单 7. 找出优先级最高的操作符


  
   
  

1. 
   
2. public static int pos_operator( Vector tokens, Range r )
   
3.    {
   
4.    byte     max_priority=Byte.MAX_VALUE;
   
5.    int      max_pos=0;
   
6.    byte     priority;
   
7.    String   operator;
   
8.    Token    t;
   
9.    for ( int i=r.start+2; i<=r.end-2; i++ )
   
10.       {
    
11.       t=(Token)tokens.elementAt( i );
    
12.       if ( t.mark!="P" )
    
13.          continue;
    
14.       priority=((Operator)t.token).priority;
    
15.       operator=((Operator)t.token).operator;
    
16.       if ( priority < max_priority || ( operator.equals("^") ||
    
17.          operator.equals("**") ) && priority == max_priority )
    
18.          {
    
19.          max_priority=priority;
    
20.          max_pos=i;
    
21.          }
    
22.       }
    
23.    return max_pos;
    
24.    }
    

复制代码

[/code]
   
  

步骤 3：如果表达式中不包含其它括号，求值的过程就完成。如果表达式包含括号，但不包含操作符，则存在需要求值的函数。  
清单 8. 检查是否还有其它操作符


  
   
  

1. 
   
2. ...
   
3. int poz_max_op=pos_operator( tokens, range );
   
4. // if there are no operators
   
5. if ( poz_max_op==0 )
   
6.    {
   
7.    if ( no_more_parentheses )
   
8.       {
   
9.       return false;
   
10.       }
    
11.    else
    
12.       {
    
13.       double   result;
    
14.       result=function_result( tokens, range.start-1 );
    
15.       function_tokens_removal( tokens, range.start-1 );
    
16.       t = new Token ( new Double(result), "D", 0, 0 );
    
17.       tokens.setElementAt( t, range.start-1 );
    
18.       parentheses_removal( tokens, range.start-1 );
    
19.       return true;
    
20.       }
    
21.    }
    
22. ...
    

复制代码

[/code]
   
  

步骤 4：所有的操作符都是二元的，也就是说第一个操作数位于操作符之前，第二个操作符位于操作符之后。  
清单 9. 获取操作数并执行运算


  
   
  

1. 
   
2. ...
   
3. double operand1, operand2;
   
4. // first operand is before...
   
5. t=(Token)tokens.elementAt( poz_max_op-1 );
   
6. operand1=operand_value( t );
   
7. // ...and second operand is after operator
   
8. t=(Token)tokens.elementAt( poz_max_op+1 );
   
9. operand2=operand_value( t );
   
10. // operator
    
11. t=(Token)tokens.elementAt( poz_max_op );
    
12. String op=((Operator)t.token).operator;
    
13. double result=operation_result( operand1, operand2, op );
    
14. tokens.removeElementAt( poz_max_op+1 );
    
15. tokens.removeElementAt( poz_max_op );
    
16. t = new Token ( new Double(result), "D", 0, 0 );
    
17. tokens.setElementAt( t, poz_max_op-1 );
    
18. parentheses_removal( tokens, poz_max_op-1 );
    
19. ...
    

复制代码

[/code]
   
  

操作数可以是变量，还可以是十进制、十六进制、八进制或二进制数。
清单 10. 获取操作数


  
   
  

1. 
   
2. public static double operand_value( Token t )
   
3.    {
   
4.    if ( t.mark=="V" )
   
5.       return ((Variable)t.token).value;
   
6.    else if ( t.mark=="D" )
   
7.       return ((Double)t.token).doubleValue();
   
8.    else if ( t.mark=="H" )
   
9.       return base_convert( ((String)t.token).substring(2), 16 );
   
10.    else if ( t.mark=="O" )
    
11.       return base_convert( ((String)t.token).substring(2), 8 );
    
12.    else if ( t.mark=="B" )
    
13.       return base_convert( ((String)t.token).substring(2), 2 );
    
14.    }
    

复制代码

[/code]
   
  

接下来的方法将不同计数制的数转化为十进制的形式。
清单 11. 将数转化为十进制数


  
   
  

1. 
   
2. public static long base_convert( String s, int base )
   
3.    {
   
4.    long r=0;
   
5.    int i, j;
   
6.    for ( i=s.length()-1, j=0; i>=0; i--, j++ )
   
7.       r=r+digit_weight( s.charAt( i ) )*(long)Math.pow( base, j );
   
8.    return r;
   
9.    }
   
10. public static int digit_weight( char c )
    
11.    {
    
12.    if ( Character.isDigit( c ) )
    
13.       return c-48;
    
14.    else if ( "A"<=c && c<="f" )
    
15.       return c-55;
    
16.    else if ( "a"<=c && c<="f" )
    
17.       return c-87;
    
18.    return -1;
    
19.    }
    

复制代码

[/code]
   
  

一旦确定操作数和操作符后，就可以执行运算了，如 清单 12所示。  步骤 5：在这步中，W3Eval 从向量中除去用过的符号并在同一位置放入结果。对于函数求值这类情况，除去的是函数、括号、自变量和逗号；而对于操作符求值这类情况而言，除去的则是操作数和操作符。  步骤 6：在求值的这一步，W3Eval 从表达式中除去冗余括号。  
清单 13. 除去冗余括号


  
   
  

1. 
   
2. private static void parentheses_removal( Vector tokens, int pos )
   
3.    {
   
4.    if (
   
5.       pos>1 &&
   
6. amp;&&
   
7. amp;
   
8.       ((Token)tokens.elementAt( poz-2 )).mark!="F" &&
   
9. amp;&&
   
10. amp;
    
11.       ((Token)tokens.elementAt( poz-1 )).mark=="(" &&
    
12. amp;&&
    
13. amp;
    
14.       ((Token)tokens.elementAt( poz+1 )).mark==")"
    
15.       ||
    
16.       pos==1 &&
    
17. amp;&&
    
18. amp;
    
19.       ((Token)tokens.elementAt( 0 )).mark=="(" &&
    
20. amp;&&
    
21. amp;
    
22.       ((Token)tokens.elementAt( 2 )).mark==")"
    
23.       )
    
24.       {
    
25.       tokens.removeElementAt( poz+1 );
    
26.       tokens.removeElementAt( poz-1 );
    
27.       }
    
28.    return;
    
29.    }
    

复制代码

[/code]
   
  

步骤 7：在求值的最后一步，向量中剩余的符号被结合到字符串，并在屏幕上显示。  
清单 14. 结合符号并显示结果


  
   
  

1. 
   
2. public static String token_join( Vector tokens )
   
3.    {
   
4.    String   result=new String();
   
5.    Token    t;
   
6.    for ( int i=0; i < tokens.size(); i++ )
   
7.       {
   
8.       t=(Token)tokens.elementAt( i );
   
9.       if ( t.mark=="D" )
   
10.          {
    
11.          double n=((Double)t.token).doubleValue();
    
12.          result=result + formated_number( n );
    
13.          }
    
14.       else
    
15.          result=result + t.token;
    
16.       if ( result.endsWith( ".0" ) )
    
17.          result=result.substring( 0, result.length()-2 );
    
18.       result=result + " ";
    
19.       }
    
20.    return result;
    
21.    }
    

复制代码

[/code]
   
  




  
   
   
   
  


结论 本文分析了一个 applet ，它能一步一步的对算术表达式求值。同时还按顺序回顾了最有意思的代码片段，并论述了两种不同的表达式求值方法。 下一版 W3Eval 有望在各方面得到增强，包括有能力添加用户定义的功能；支持分数、复数和矩阵；改良的图形用户界面（GUI）；大小和速度优化以及安全性方面的增强。我鼓励您提供您自己对于增强方面的设想。 我希望您会发现 W3Eval 是个对表达式求值有益的在线工具，它在某种程度上比经典的方法更简单自然。我还期待这里谈到的代码和算法使您明白 Java 语言有助于处理数学问题。 参考资料  

W3Eval applet是免费的，它的 帮助有助于您解决问题。



这张表格展示了 W3Eval 操作符的优先级。




  
  
   
   

     
   

     
   
  











源码下载：http://file.javaxxz.com/2014/10/1/115927641.zip