在写一个计算四则运算表达式的程序,想用堆栈去实现,因此要将表达式里面的数字和运算符分开来保存
例如2.5*4+(2*5)
想将2.5,4,2,5这个数存入一数组,而*,+(,)存入另一数组,Java中的split方法好像不能实现这个功能,求高手给思路!!!
例如2.5*4+(2*5)
想将2.5,4,2,5这个数存入一数组,而*,+(,)存入另一数组,Java中的split方法好像不能实现这个功能,求高手给思路!!!
Pattern p;
Matcher m;
p = Pattern.compile("\\+|\\-|\\*|\\/|\\(|\\)");
m = p.matcher(str);
while(m.find()){
System.out.println(m.group());
}
p = Pattern.compile("\\d+(\\.\\d+)*");
m = p.matcher(str);
while(m.find()){
System.out.println(m.group());
}
http://blog.csdn.net/antineutrino/article/details/6763722
分割字符看你想怎么解析,也就是说 2.5合法,2. 5算不算合法的问题,如果中间的存在空格可以合法,那么去掉所有的空格后,在把字符串变成字符数组,然后遍历该字符数组即可,如果中间存在空格算不合法,那么做法一样,只是在遍历的过程中要自己判断空格符
给段小例子import java.util.*;public class Test {
static final String symbol = "+-*/()"; //运算符
static final String[] priority = {"+-", "*/", "()"}; //运算符优先级 static Comparator<String> comp = new Comparator<String>() { //运算符比较器
public int compare(String s1, String s2) {
int n1=0, n2=0;
for (int i=0; i<priority.length; i++) {
if (priority[i].indexOf(s1) >= 0) {n1 = i;}
if (priority[i].indexOf(s2) >= 0) {n2 = i;}
}
return (n1 - n2);
}
}; public static void main(String[] args) throws Throwable {
String exp = "2.5*4+(2*5)";
List<String> list = analyze(exp); //中缀转后缀
System.out.println(list);
double result = cacl(list); //计算结果
System.out.printf("%.2f\n", result);
} public static List<String> analyze(String exp) throws Exception { //分析
if (exp == null) {
throw new Exception ("illegal parameter.");
}
exp = exp.replaceAll("\\s*", ""); //去掉所有的空格(为了方便中间存在空格算合法)
List<String> list = new ArrayList<String>();
Stack<String> sym = new Stack<String>(); StringBuilder buf = new StringBuilder();
for (char c : exp.toCharArray()) {
if (symbol.indexOf(c) >= 0) { //如果是运算符
if (buf.length() > 0) { //如果有操作数
String v = buf.toString();
if (! v.matches("\\d+([.]\\d+)?")) {
throw new Exception ("illegal varaible("+v+").");
}
list.add(v);
buf.delete(0, buf.length());
} if (c == '(') {
sym.push(String.valueOf(c));
} else if (c == ')') {
String last = "";
while (sym.size() > 0) {
last = sym.pop();
if (last.equals("(")) {
break;
} else {
list.add(last);
}
}
if (!"(".equals(last)) {
throw new Exception ("illigal express.");
}
} else if (sym.size() > 0) {
String s = String.valueOf(c);
String last = sym.peek();
if (last.equals("(") || comp.compare(s, last) > 0) {
sym.push(s);
} else {
last = sym.pop();
list.add(last);
sym.push(s);
}
} else {
sym.push(String.valueOf(c));
}
} else { //不是运算符则当作操作数(因为已经去除所有空格,这里不再需要判断空格)
buf.append(c);
}
} if (buf.length() > 0) {
list.add(buf.toString());
} while (sym.size() > 0) {
String last = sym.pop();
if ("()".indexOf(last) >= 0) {
throw new Exception ("illigal express.");
}
list.add(last);
}
return list;
} public static double cacl(List<String> list) throws Exception { //计算
Stack<Double> val = new Stack<Double>();
double result = 0;
while (list.size() > 0) {
String s = list.remove(0);
if (symbol.indexOf(s) >= 0) {
double d1 = val.pop();
double d2 = val.pop();
if ("+".equals(s)) {
result = d2 + d1;
} else if ("-".equals(s)) {
result = d2 - d1;
} else if ("*".equals(s)) {
result = d2 * d1;
} else if ("/".equals(s)) {
result = d2 / d1;
} else {
throw new Exception ("illigal symbol("+s+").");
}
val.push(result);
} else {
if (!s.matches("\\d+([.]\\d+)?")) {
throw new Exception ("illigal variable("+s+").");
}
val.push(Double.valueOf(s));
}
}
return result;
}
}