java程序难题

Question

用java编写一个数学公式解析器，要求能够实现任意正整数的加减乘除功能，并支持括号优先级，请注
意代码质量，不允许调用语言自带的表达式解析功能来实现。

Answer 1

中缀表达式转后缀表达式
以前有人问过了，给你个链接，自己看吧
http://topic.csdn.net/u/20110519/20/b23b6aaa-fd3f-4abb-aa1a-6f95b2ca9696.html

Answer 2

我的没法达到LZ要求的任意整数，我的最大到double的取值范围。

Answer 3

可以计算包含正负数、小数、括号的四则运算import java.util.regex.Matcher;   
import java.util.regex.Pattern;   
  
public class Test{   
    public static void main(String[] args){   
        String result = compute("-2/6+-3");   
        System.out.println(result);   
    }   
  
    public static String compute(String expression){   
        expression = "(" + expression + ")";   
        String regex = "(.*?)(\\([^()]+\\))(.*)";   
        Pattern pattern = Pattern.compile(regex);   
        Matcher matcher = pattern.matcher(expression);   
  
        while(matcher.find()){   
            expression = matcher.group(1) + compute1(matcher.group(2)) + matcher.group(3);   
            matcher = pattern.matcher(expression);   
            System.out.println(expression);   
        }   
  
        return expression;   
    }   
  
    private static String compute1(String expression){   
        /*  
        计算没有包含括号的情况下的结果  
        */  
        expression = expression.replaceAll("[( )]","");   
        String regex = "^(.*?)(\\d+(?:\\.\\d+)?)([/*])(-?\\d+(?:\\.\\d+)?)(.*)";   
        Pattern pattern = Pattern.compile(regex);   
        Matcher matcher = pattern.matcher(expression);   
  
        double value1 = 0.0;   
        double value2 = 0.0;   
  
        String temp = null;   
  
        while(matcher.find()){   
            value1 = Double.valueOf(matcher.group(2));   
            value2 = Double.valueOf(matcher.group(4));   
            if(matcher.group(3).equals("*")){   
                temp = (value1 * value2) + "";   
            }else{   
                temp = (value1 / value2) + "";   
            }   
  
  
            expression = matcher.group(1) + temp + matcher.group(5);   
            expression = expression.replaceAll("--","+");   
            matcher = pattern.matcher(expression);   
        }   
  
        //System.out.println(expression);   
  
        regex = "^(.*?)((?:(?=[-+*/])-)?\\d+(?:\\.\\d+)?)([-+])(-?\\d+(?:\\.\\d+)?)(.*)";   
        pattern = Pattern.compile(regex);   
        matcher = pattern.matcher(expression);   
  
        while(matcher.find()){   
               
            value1 = Double.valueOf(matcher.group(2));   
               
            value2 = Double.valueOf(matcher.group(4));   
  
            if(matcher.group(3).equals("+")){   
                temp = (value1 + value2) + "";   
            }else{   
                temp = (value1 - value2) + "";   
            }   
  
            expression = matcher.group(1) + temp + matcher.group(5);   
            matcher = pattern.matcher(expression);   
        }   
  
        expression = expression.replaceAll("\\+","");   
  
        return expression;   
    }   
}  
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/micsolaris/archive/2010/07/29/5772782.aspx

Answer 4

package CSDN;import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;public class CalExpression_js {
 public static void main(String[] args) throws ScriptException {
        String ex = "(1+3)*(6-5)+6";
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("javascript");
        System.out.print(engine.eval(ex));
    }
}

Answer 5

LZ说了“不允许调用语言自带的表达式解析功能来实现。”用正则的 js的 都不合格啊

Answer 6

自己写的中缀转后缀，写的不好就当参考吧import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Stack;
public class Test6 {
public static void main(String[] args) {
System.out.println("请输入一个四则运算式：");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine()+"#";
LinkedList ll = m2(str);
double result = m3(ll);
System.out.println("结果= "+result);
}
/*
 * m方法对算术式各部分进行分级，结束标志#为-1，普通数值为0，+和-为1，*和/为2，‘（’为3，‘）’为4。
 */
private static int m(Character c) {
if(c.equals(')')) {
return 4;
}
else if(c.equals('(')) {
return 3;
}
else if(c.equals('*')||c.equals('/')) {
return 2;
}
else if(c.equals(('+'))||c.equals('-')) {
return 1;
}
else if(c.equals('#')) {
return -1;
}
else return 0;
}
/*
 * 对算术式str进行后缀转换，从下标0到str.length-1结束。
 * 转换成功后，后缀表达式保存在LinkedList里，并且返回，数值的保存类型为StringBuilder,操作符为Character.
 */
private static LinkedList m2(String str) {
LinkedList ll = new LinkedList();
Stack<Character> al = new Stack<Character>();
al.add('#');
StringBuilder sb = new StringBuilder();
for(int i = 0; i < str.length();i++) {
Character c = str.charAt(i);
if(m(c)==0) {
sb.append(c);
}
else if(m(c)>0||(m(c)<0&&!sb.toString().equals(""))) {
if(!sb.toString().equals("")) {
ll.add(sb);
sb = new StringBuilder();
}
if(m(c)-m(al.peek())>0&&m(c)!=4) {
al.push(c);
}
else if(m(al.peek())==3) {
al.push(c);
}
else if(m(c)!=4&&m(c)-m(al.peek())<=0&&m(c)!=-1) {
while(m(c)-m(al.peek())<=0&&m(al.peek())!=3){
ll.add(al.pop());
}
al.push(c);
}
else if(m(c)==4) {
while(m(al.peek())!=3) {
ll.add(al.pop());
}
al.pop();
}
else {
while(m(al.peek())!=-1) {
ll.add((al.pop()));
}
}
}
else {
while(m(al.peek())!=-1) {
ll.add((al.pop()));
}
}
}
return ll;
}

/*
 * 把转换成后缀式的算术式进行计算，result记录结果。
 * 后缀式保存在LinkedList的一个对象ll里。
 * 最后返回计算结果result.
 */
private static double m3(LinkedList ll) {
double result = 0;
for(int i = 0; i < ll.size();i++) {
String str2 = ll.get(i).toString();
if(str2.equals("+")) {
result = Double.valueOf(ll.get(i-2).toString())+Double.valueOf(ll.get(i-1).toString());
ll.set(i, result);
ll.remove(i-2);
ll.remove(i-2);
i = i-2;
}
else if(str2.equals("-")) {
result = Double.valueOf(ll.get(i-2).toString())-Double.valueOf(ll.get(i-1).toString());
ll.set(i, result);
ll.remove(i-2);
ll.remove(i-2);
i = i-2;
}
else if(str2.equals("*")) {
result = Double.valueOf(ll.get(i-2).toString())*Double.valueOf(ll.get(i-1).toString());
ll.set(i, result);
ll.remove(i-2);
ll.remove(i-2);
i = i-2;
}
else if(str2.equals("/")) {
result = Double.valueOf(ll.get(i-2).toString())/Double.valueOf(ll.get(i-1).toString());
ll.set(i, result);
ll.remove(i-2);
ll.remove(i-2);
i = i-2;
}
}
return result;
}
}

Answer 7

大哥你学java多久了，真复杂啊，高手真多啊。