一、算述表达式 优先级高 左结合
 
赋值表达式 优先级低 右结合
 
二、关系表达式（比较）
 
1、关系表达式（左结合）：
 
优先级次于算述表达式
 
（1）<、>、<=、>=优先级高
 
（2）==（等于）、！=（不等于）优先级低
 
2、成立不成立
 
成立：命题为真（true）值为1
 
不成立：命题为假（false）值为0
 
三、条件表达式（三目运算符）
 
1、格式：
 
表达式1 ？ 表达式 2： 表达式3
 
2、含义：
 
整个表达式的值由表达式1决定；
 
若表达式1成立，则整个条件表达式的值为表达式2的值；
 
若表达式1不成立，则整个条件表达式的值为表达式3的值。
 
例：
 
求三数表达式：
 
d=x>y?x:y;
 
e=d>z?d:z
 
或
 
d=x>y?(x>z?x:z):(y>z?y:z)
 
3、表达式1的成立与不成立
 
非0（值为1）——>成立
 
0——>不成立
 
4、优先级：只高于赋值法
 
结合性：
 
右结合
 
四、逻辑表达式
 
1、逻辑表达符
 
！（单目）取反　　非运算　　优先级高于算述运算符
 
&&（双目）并且　　或运算　　优先级低于运算符
 
||（双目）或者　　与运算　　运算符低于&&
 
&&：
 
两个表达式都成立时成立　　否则不成立
 
||：
 
两个表达式其中任何一个成立就成立，只有两个都不成立时不成立
 
3、短路问题：
 
||：
 
左边成立情况下编译器不计算右边
 
&&：
 
左边不成立情况下编译器不计算右边

例1：
 
1！=3>4  运算结果为多少？
 
结果为： 1
 
例2：
 
int x;
 
x=100;
 
printf("%d",x>10);
 
结果：1
 

 
 
分析：
 
1、关系运算符有>、<、>=、<=、==、!= 6个，前四个优先级大于后两个；逻辑表达式有！（非）&&（与）||（或）；
 
    优先级：！--算术运算符--关系运算符--&&--||--赋值运算符；
 
2、关系、逻辑表达式的运算结果是一个逻辑值，1（真），0（假），不存在其他值，它们的值可作为算术值处理；
 
3、3>4运算结果为假（0）,1！=0运算结果为真（1）；
 
4、逻辑表达式中，若某一步已得到整个表达式的结果，后面的部分将不再运算！
 
    如：int a=1,b=0,c;
 
          c=a||++b;
 
          结果b的值仍为0；
 

 
 
         c=b&&a++;
 
          结果a的值仍为1
 
5、a>b>c，在C语言中应写为a>b&&b>c。
 

 

在C#语言的编程中，经常会用到关系表达式和逻辑表达式，或者二者的混合运用。
 
 
1、关系表达式是由关系运算符组成的。比如：>、<、>=、<=、==、!=。运用这几个运算符构成的表达式就叫做关系表达式。举例如下：
 
int number_01;
 
int number_02;
 
//输入number_01的值
 
Console.Write("请输入number_01的值：");
 
number_01=Console.ReadLine();
 
//输入number_02的值
 
Console.Write("请输入number_02的值：");
 
number_02=Console.ReadLine();
 
 
if(number_01==number_02)
 
{
 
Console.WriteLine("number_01和number_02相等");
 
}
 
 
if(number_01!=number_02)
 
{
 
Console.WriteLine("number_01和number_02不相等");
 
}
 
 
if(number_01>number_02)
 
{
 
Console.WriteLine("number_01大于number_02");
 
}
 
 
if(number_01>=number_02)
 
{
 
Console.WriteLine("number_01大于或者等于number_02");
 
}
 
 
if(number_01<number_02)
 
{
 
Console.WriteLine("number_01小于number_02");
 
}
 
 
if(number_01<=number_02)
 
{
 
Console.WriteLine("number_01小于或等于number_02");
 
}
 
 
2、逻辑表达式是由逻辑运算符组成的。主要有：&、|、!、^。
 
逻辑与&的规则：
 
逻辑与两边的逻辑值都为true，结果才为true；否则为false。
 
true&true=true
 
true&false=false
 
false&true=false
 
false&false=false
 
 
逻辑或的规则：
 
逻辑或两边的逻辑值只要有一个为true，结果就为true。
 
true|true=true
 
true|false=true
 
false|true=true
 
false|false=false
 
 
逻辑非为取相反的值。
 
！false=true
 
!true=false
 
 
逻辑异或：
 
逻辑异或为两边的值相同时为false，其它的情况为true。
 
true^true=false
 
true^false=true
 
false^true=true
 
false^false=false

    项目中要实现校验公式，一开始使用BeanShell插件求值，后来改用Dijkstra(迪杰斯特拉)算法自己实现表达式求值。该算法使用一个符号栈和一个数值栈，遍历表达式字符串当遇到数值时入数值栈。当遇到符号时若比符号栈顶的符号优先级高则入符号栈，若比符号栈顶的符号优先级低，则先把两栈中能计算的统统计算掉（直到符号栈顶的符号优先级小于遇到的符号）。遍历完再计算掉两栈中剩余的项。对于括号的处理也是类似，遇到左括号则入符号栈，遇到右括号则统统计算掉，直到遇到左括号。
 
    计算是指：符号栈退栈得符号，数值栈连退两栈（若是二元运算符的话）得两个数值，将得到的数值用符号运算符计算，得到的结果再压回数值栈。实现的源码如下：
 
package com.huateng.report.pboccbrcdemo.util;

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

/**
 * 
 * 计算算术表达式或逻辑表达式的值
 * 
 * @author zhou_yiqing
 * @since 2013-5-7
 * @version 1.0
 * 
 */

public class ExpressionEvaluator {
	private static Map<String, Integer> opLvl;
	
	static {
		init();
	}
	
	private static void init() {
		opLvl = new HashMap<String, Integer>();
		opLvl.put("||", 0);
		opLvl.put("&&", 1);
		opLvl.put(">", 2);
		opLvl.put("<", 2);
		opLvl.put(">=", 2);
		opLvl.put("<=", 2);
		opLvl.put("==", 2);
		opLvl.put("!=", 2);
		opLvl.put("+", 3);
		opLvl.put("-", 3);
		opLvl.put("*", 4);
		opLvl.put("/", 4);
		opLvl.put("sqr", 5);
		opLvl.put("(", -1);
		opLvl.put(")", -2);
	}
	
	/**
	 * 计算中缀表达式
	 * @param nifix 以算术或逻辑中缀表达式
	 * @return 若为算术值则是Integer或Double实例，若为逻辑值则是Boolean实例
	 * @throws Exception
	 */
	public static Object calcNifix(String nifix) throws Exception {
		Object ret = null;
		Stack<String> opStack = new Stack<String>();
		Stack<Object> oaStack = new Stack<Object>();
		int length = nifix.length();
		int begin = 0;
		boolean numStat = true;
		
		for (int i=0; i<length; i++) {
			char c = nifix.charAt(i);
			if (Character.isDigit(c) || c=='.') { // 遇到数值
				if (!numStat) {
					throw new Exception("无法识别的运算符\""+nifix.substring(begin, i)+ "\"");
				} else {
					numStat = true;
				}
			} else if (Character.isSpaceChar(c)) { // 遇到空白
				continue;
			} else { // 遇到运算符
				if  (numStat) {
					if (begin != i) {
						String oa = nifix.substring(begin, i).trim();
						if (!"".equals(oa)) {
							try {
								if (oa.indexOf(".") != -1) {
									oaStack.push(Double.parseDouble(oa));
								} else {
									oaStack.push(Integer.parseInt(oa));
								}
							} catch (Exception e) {
								throw new Exception("无法识别的数值：" + oa);
							}
						}
					}
					begin = i;
					numStat = false;
				}
				String op = nifix.substring(begin, i+1).trim();
				if (opLvl.containsKey(op)) {
					if (">".equals(op) || "<".equals(op)) {
						if (i+1 < length && nifix.charAt(i+1) == '=') {
							continue;
						}
					}
					int lvl = opLvl.get(op);
					switch (lvl) {
					case 5:
						opStack.push(op);
						break;
					case -1:
						opStack.push(op);
						break;
					case -2:
						try {
							calcStack(opStack, oaStack, true, -1);
						} catch (Exception e) {
							throw new Exception("第" + i + "列附近出现错误："+ e.getMessage());
						}
						if (!opStack.isEmpty()) {
							String topOp = opStack.peek();
							if (opLvl.get(topOp) >= 5) {
								opStack.pop();
								Double result = null;
								try {
									result =  calcSingleOperator(oaStack.pop(), topOp);
								} catch (Exception e) {
									throw new Exception("第" + i + "列附近出现错误："+ e.getMessage());
								}
								oaStack.push(result);
							}
						}
						break;
					default:
						if (!opStack.isEmpty()) {
							try {
								calcStack(opStack, oaStack, false, lvl);
							} catch (Exception e) {
								throw new Exception("第" + i + "列附近出现错误："+ e.getMessage());
							}
							opStack.push(op);
						} else {
							opStack.push(op);
						}
						break;
					}
					begin = i+1;
					numStat = true;
				}
			}
		}
		if (!oaStack.isEmpty()) {
			if (!opStack.isEmpty()) {
				if (begin < length) {
					String oa = nifix.substring(begin, length).trim();
					if (!"".equals(oa)) {
						try {
							if (oa.indexOf(".") != -1) {
								oaStack.push(Double.parseDouble(oa));
							} else {
								oaStack.push(Integer.parseInt(oa));
							}
						} catch (Exception e) {
							throw new Exception("无法识别的数值：" + oa);
						}
					}
				}
				ret = calcStack(opStack, oaStack, false, Integer.MIN_VALUE);
			} else {
				return oaStack.pop();
			}
		} else {
			String str = nifix.trim();
			try {
				if (str.indexOf(".") != -1) {
					ret = Double.parseDouble(nifix.trim());
				} else {
					ret = Integer.parseInt(nifix.trim());
				}
			} catch (Exception e) {
				throw new Exception("无法识别的数值：" +str);
			}
		}
		
		return ret;
	}
	
	/**
	 * 计算一元运算符
	 */
	private static Double calcSingleOperator(Object oa, Object op) throws Exception {
		if ("sqr".equals(op)) {
			if (oa instanceof Integer) {
				return Math.sqrt((Integer)oa);
			} else if (oa instanceof Double) {
				return Math.sqrt((Double)oa);
			} else {
				throw new Exception("一元运算类型不匹配");
			}
		} else {
			throw new Exception("未知的一元运算符："+ op);
		}
	}
	
	/**
	 * 二元运算符计算
	 */
	private static Number calcCalculateOperator(Object oa1, Object oa2, String op) throws Exception {
		if ("+".equals(op)) {
			if (oa2 instanceof Integer && oa1 instanceof Integer) {
				return (Integer)oa2 + (Integer)oa1;
			} else if (oa2 instanceof Integer && oa1 instanceof Double) {
				return (Integer)oa2 + (Double)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Integer) {
				return (Double)oa2 + (Integer)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Double) {
				return (Double)oa2 + (Double)oa1;
			} else {
				throw new Exception("二元运算类型不匹配");
			}
		} else if ("-".equals(op)) {
			if (oa2 instanceof Integer && oa1 instanceof Integer) {
				return (Integer)oa2 - (Integer)oa1;
			} else if (oa2 instanceof Integer && oa1 instanceof Double) {
				return (Integer)oa2 - (Double)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Integer) {
				return (Double)oa2 - (Integer)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Double) {
				return (Double)oa2 - (Double)oa1;
			} else {
				throw new Exception("二元运算类型不匹配");
			}
		} else if ("*".equals(op)) {
			if (oa2 instanceof Integer && oa1 instanceof Integer) {
				return (Integer)oa2 * (Integer)oa1;
			} else if (oa2 instanceof Integer && oa1 instanceof Double) {
				return (Integer)oa2 * (Double)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Integer) {
				return (Double)oa2 * (Integer)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Double) {
				return (Double)oa2 * (Double)oa1;
			} else {
				throw new Exception("二元运算类型不匹配");
			}
		} else if ("/".equals(op)) {
			if (oa2 instanceof Integer && oa1 instanceof Integer) {
				return (Integer)oa2 / (Integer)oa1;
			} else if (oa2 instanceof Integer && oa1 instanceof Double) {
				return (Integer)oa2 / (Double)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Integer) {
				return (Double)oa2 / (Integer)oa1;
			} else if (oa2 instanceof Double && oa1 instanceof Double) {
				return (Double)oa2 / (Double)oa1;
			} else {
				throw new Exception("二元运算类型不匹配");
			}
		} else {
			throw new Exception("未知的二元运算符：" + op);
		}
	}
	
	/**
	 * 计算逻辑运算符 
	 */
	private static Boolean calcLogicOperator(Object oa1, Object oa2, String op) throws Exception {
		if (oa1 instanceof Boolean && oa2 instanceof Boolean) {
			if ("||".equals(op)) {
				return (Boolean)oa2 || (Boolean)oa1;
			} else if ("&&".equals(op)){
				return (Boolean)oa2 && (Boolean)oa1;
			} else {
				throw new Exception("未知的逻辑运算符：" + op);
			}
		} else {
			throw new Exception("逻辑判断类型不匹配");
		}
		
	}
	
	/**
	 * 计算关系运算符
	 */
	private static Boolean calcRelationOperator(Object oa1, Object oa2, String op) throws Exception {
		if (oa2 instanceof Integer && oa1 instanceof Integer) {
			if (">".equals(op)) {
				return (Integer)oa2 > (Integer)oa1;
			} else if ("<".equals(op)) {
				return (Integer)oa2 < (Integer)oa1;
			} else if (">=".equals(op)) {
				return ((Integer)oa2).intValue() >=  ((Integer)oa1).intValue();
			} else if ("<=".equals(op)) {
				return ((Integer)oa2).intValue() <=  ((Integer)oa1).intValue();
			} else if ("==".equals(op)) {
				return ((Integer)oa2).intValue() ==  ((Integer)oa1).intValue();
			} else if ("!=".equals(op)) {
				return ((Integer)oa2).intValue() !=  ((Integer)oa1).intValue();
			} else {
				throw new Exception("未知的关系运算符：" + op);
			}
		} else if (oa2 instanceof Integer && oa1 instanceof Double) {
			if (">".equals(op)) {
				return (Integer)oa2 > (Double)oa1;
			} else if ("<".equals(op)) {
				return (Integer)oa2 < (Double)oa1;
			} else if (">=".equals(op)) {
				return ((Integer)oa2).intValue() >=  ((Double)oa1).doubleValue();
			} else if ("<=".equals(op)) {
				return ((Integer)oa2).intValue() <=  ((Double)oa1).doubleValue();
			} else if ("==".equals(op)) {
				return ((Integer)oa2).intValue() ==  ((Double)oa1).doubleValue();
			} else if ("!=".equals(op)) {
				return ((Integer)oa2).intValue() !=  ((Double)oa1).doubleValue();
			} else {
				throw new Exception("未知的关系运算符：" + op);
			}
		} else if (oa2 instanceof Double && oa1 instanceof Integer) {
			if (">".equals(op)) {
				return (Double)oa2 > (Integer)oa1;
			} else if ("<".equals(op)) {
				return (Double)oa2 < (Integer)oa1;
			} else if (">=".equals(op)) {
				return ((Double)oa2).doubleValue() >=  ((Integer)oa1).intValue();
			} else if ("<=".equals(op)) {
				return ((Double)oa2).doubleValue() <=  ((Integer)oa1).intValue();
			} else if ("==".equals(op)) {
				return ((Double)oa2).doubleValue() ==  ((Integer)oa1).intValue();
			} else if ("!=".equals(op)) {
				return ((Double)oa2).doubleValue() !=  ((Integer)oa1).intValue();
			} else {
				throw new Exception("未知的关系运算符：" + op);
			}
		} else if (oa2 instanceof Double && oa1 instanceof Double) {
			if (">".equals(op)) {
				return (Double)oa2 > (Double)oa1;
			} else if ("<".equals(op)) {
				return (Double)oa2 < (Double)oa1;
			} else if (">=".equals(op)) {
				return ((Double)oa2).doubleValue() >=  ((Double)oa1).doubleValue();
			} else if ("<=".equals(op)) {
				return ((Double)oa2).doubleValue() <=  ((Double)oa1).doubleValue();
			} else if ("==".equals(op)) {
				return ((Double)oa2).doubleValue() ==  ((Double)oa1).doubleValue();
			} else if ("!=".equals(op)) {
				return ((Double)oa2).doubleValue() !=  ((Double)oa1).doubleValue();
			} else {
				throw new Exception("未知的关系运算符：" + op);
			}
		} else {
			throw new Exception("关系运算类型不匹配");
		}
	}
	
	/**
	 * 计算运算符栈
	 * @param opStack 运算符栈
	 * @param oaStack 运算成员栈
	 * @param popParenth 是否一直计算到左括号
	 * @param lvlDeep 运算符级别深度
	 * @return Integer或Double或Boolean的运算结果
	 * @throws Exception
	 */
	private static Object calcStack(Stack<String> opStack, 
			Stack<Object> oaStack, boolean popParenth, int lvlDeep) throws Exception {
		Object ret = null;
		while (!opStack.isEmpty()) {
			String topOp = opStack.peek();
			if (!popParenth) {
				int lvl = opLvl.get(topOp);
				if (lvl >= lvlDeep) {
					opStack.pop();
					Object oa1 = oaStack.pop();
					Object oa2 = oaStack.pop();
					Object result = null;
					if (lvl < 2) {
						result = calcLogicOperator(oa1, oa2, topOp);
					} else if (lvl < 3) {
						result = calcRelationOperator(oa1, oa2, topOp);
					} else if (lvl < 5) {
						result = calcCalculateOperator(oa1, oa2, topOp);
					}
					oaStack.push(result);
					ret = result;
				} else {
					break;
				}
			} else {
				if (!"(".equals(topOp)) {
					opStack.pop();
					Object oa1 = oaStack.pop();
					Object oa2 = oaStack.pop();
					int lvl = opLvl.get(topOp);
					Object result = null;
					if (lvl < 2) {
						result = calcLogicOperator(oa1, oa2, topOp);
					} else if (lvl < 3) {
						result = calcRelationOperator(oa1, oa2, topOp);
					} else if (lvl < 5) {
						result = calcCalculateOperator(oa1, oa2, topOp);
					}
					oaStack.push(result);
					ret = result;
				} else {
					opStack.pop();
					break;
				}
			}
		}
		return ret;
	}
	
	/*public static void main(String[] args) throws Exception {
	//	System.out.println(calcNifix("9+2*3+10/2"));
		System.out.println(calcNifix("(2<3+3)&&(3>9||4>2)"));
		System.out.println(calcNifix(
				"62202.00>=323.00+545.00+ 453.00+47.00+233.00+468.00+34.00+323.00+32.00+3213.00+3213.00+4342.00+34242.00+543.00+546.00+6757.00+213.00+3243.00+3432.00"));
		System.out.println(calcNifix(" (2)+ (3-6)"));
		System.out.println(calcNifix("sqr(4)"));
		System.out.println(calcNifix(" 1+ 2- ( 3+( sqr( 4 )-5) +1) "));
		System.out.println(calcNifix("9+(3-1)*3+10/2"));
	}*/

}