string aa = "(1+2)/3+(3+4)*5"; DataTable dt = new DataTable(); string b = dt.Compute(aa, "").ToString(); Response.Write(b);
扩展：C#中DataTable中的Compute方法使用收集
java算法1：尚未验证
import java.util.HashMap; import java.util.Map; public abstract class Operator { /** * 运算符 */ private char operator; /** * 运算符的优先级别，数字越大，优先级别越高 */ private int priority; private static Map<Character, Operator> operators = new HashMap<Character, Operator>(); private Operator(char operator, int priority) { setOperator(operator); setPriority(priority); register(this); } private void register(Operator operator) { operators.put(operator.getOperator(), operator); } /** * 加法运算 */ public final static Operator ADITION = new Operator('+', 100) { public double eval(double left, double right) { return left + right; } }; /** * 减法运算 */ public final static Operator SUBTRATION = new Operator('-', 100) { public double eval(double left, double right) { return left - right; } }; /** * 乘法运算 */ public final static Operator MULTIPLICATION = new Operator('*', 200) { public double eval(double left, double right) { return left * right; } }; /** * 除法运算 */ public final static Operator DIVITION = new Operator('/', 200) { public double eval(double left, double right) { return left / right; } }; /** * 冪运算 */ public final static Operator EXPONENT = new Operator('^', 300) { public double eval(double left, double right) { return Math.pow(left, right); } }; /** * 取模运算 */ public final static Operator MOD = new Operator('%', 200) { public double eval(double left, double right) { return left % right; } }; public char getOperator() { return operator; } private void setOperator(char operator) { this.operator = operator; } public int getPriority() { return priority; } private void setPriority(int priority) { this.priority = priority; } /** * 根据某个运算符获得该运算符的优先级别 * @param c * @return 运算符的优先级别 */ public static int getPrority(char c) { Operator op = operators.get(c); if(op != null) { return op.getPriority(); } return 0; } /** * 工具方法，判断某个字符是否是运算符 * @param c * @return 是运算符返回 true，否则返回 false */ public static boolean isOperator(char c) { return getInstance(c) != null; } public static boolean isOperator(String str) { if(str.length() > 1) { return false; } return isOperator(str.charAt(0)); } /** * 根据运算符获得 Operator 实例 * @param c * @return 从注册中的 Operator 返回实例，尚未注册返回 null */ public static Operator getInstance(char c) { return operators.get(c); } public static Operator getInstance(String str) { if(str.length() > 1) { return null; } return getInstance(str.charAt(0)); } /** * 根据操作数进行计算 * @param left 左操作数 * @param right 右操作数 * @return 计算结果 */ public abstract double eval(double left, double right); }
java算法2：尚未验证
public class Test { public static void main(String[] args) { String str = "40944.0501-3.2*100"; Calculator cal = new Calculator(); double d = cal.eval(str); System.out.println(d); } } public interface MathSymbol { /** * 左括号 */ public final static char LEFT_BRACKET = '('; /** * 右括号 */ public final static char RIGHT_BRACKET = ')'; /** * 中缀表达式中的空格，需要要忽略 */ public final static char BLANK = ' '; /** * 小数点符号 */ public final static char DECIMAL_POINT = '.'; /** * 负号 */ public final static char NEGATIVE_SIGN = '-'; /** * 正号 */ public final static char POSITIVE_SIGN = '+'; /** * 后缀表达式的各段的分隔符 */ public final static char SEPARATOR = ' '; } import java.util.Stack; public class Calculator implements MathSymbol { /** * 计算中缀表达式 * @param expression * @return */ public double eval(String expression) { String str = infix2Suffix(expression); //System.out.println(" Infix Expression: " + expression); //System.out.println("Suffix Expression: " + str); if(str == null) { throw new IllegalArgumentException("Expression is null!"); } String[] strs = str.split("\s+"); Stack<String> stack = new Stack<String>(); for(int i = 0; i < strs.length; i++) { if(!Operator.isOperator(strs[i])) { stack.push(strs[i]); } else { Operator op = Operator.getInstance(strs[i]); double right = Double.parseDouble(stack.pop()); double left = Double.parseDouble(stack.pop()); double result = op.eval(left, right); stack.push(String.valueOf(result)); } } return Double.parseDouble(stack.pop()); } /** * 将中缀表达式转换为后缀表达式 * @param expression * @return */ public String infix2Suffix(String expression) { if(expression == null) { return null; } char[] chs = expression.toCharArray(); Stack<Character> stack = new Stack<Character>(); StringBuilder sb = new StringBuilder(chs.length); boolean appendSeparator = false; boolean sign = true; for(int i = 0; i < chs.length; i++) { char c = chs[i]; if(c == BLANK) { continue; } // Next line is used output stack information. // System.out.printf("%-20s %s%n", stack, sb.toString()); if(appendSeparator) { sb.append(SEPARATOR); appendSeparator = false; } if(isSign(c) && sign) { sb.append(c); continue; } if(isNumber(c)) { sign = false; sb.append(c); continue; } if(isLeftBracket(c)) { stack.push(c); continue; } if(isRightBracket(c)) { sign = false; while(stack.peek() != LEFT_BRACKET) { sb.append(SEPARATOR); sb.append(stack.pop()); } stack.pop(); continue; } appendSeparator = true; if(Operator.isOperator(c)) { sign = true; if(stack.isEmpty() || stack.peek() == LEFT_BRACKET) { stack.push(c); continue; } int precedence = Operator.getPrority(c); while(!stack.isEmpty() && Operator.getPrority(stack.peek()) >= precedence) { sb.append(SEPARATOR); sb.append(stack.pop()); } stack.push(c); } } while(!stack.isEmpty()) { sb.append(SEPARATOR); sb.append(stack.pop()); } return sb.toString(); } /** * 判断某个字符是否是正号或者负号 * @param c * @return */ private boolean isSign(char c) { if(c == NEGATIVE_SIGN || c == POSITIVE_SIGN) { return true; } return false; } /** * 判断某个字符是否为数字或者小数点 * @param c * @return */ private boolean isNumber(char c) { if((c >= '0' && c <= '9') || c == DECIMAL_POINT) { return true; } return false; } /** * 判断某个字符是否为左括号 * @param c * @return */ private boolean isLeftBracket(char c) { return c == LEFT_BRACKET; } /** * 判断某个字符是否为右括号 * @param c * @return */ private boolean isRightBracket(char c) { return c == RIGHT_BRACKET; } }