因此，如果我有一个括号括在括号之间或括号外的任何括号，我怎么能删除最外面的括号对，使用递归并调用parseFactor（每次我看到一组括号我调用parseFactor）？由于这很模糊，我会举一个例子说明我的意思。以此为例（这不是我试图解决的具体问题，只是一个大致的想法）：
如果我有表达式
((4+1)*1) + 5
我想打破这一点，以便我首先得到(4+1)*1（无论第一对括号中是什么）。然后，再次调用parseFactor函数，因为我看到另一组括号，然后调用parseExpression的parseFactor将使用递归进行内部计算。这意味着我得到5*1。然后我用函数parseTerm进行计算，得到5。一旦我退出递归，我得到5+5然后我调用另一个名为parseExpression的函数，它将计算5 + 5并返回10.
目前，我在parseFactor中使用Matcher m = Pattern.compile("\\((.*)").matcher(expr)).find()，然后将结果分组以删除第一个括号，引导我(4+1)*1) + 5。我再次调用parseFactor获得4 + 1）* 1）+ 5.问题是我不知道如何摆脱外括号。这是我的代码供参考，如果有人需要它：
else if(Pattern.matches("\\(.*", expr)){
(m = Pattern.compile("\\((.*)").matcher(expr)).find();
String save = m.group(1);
(m = Pattern.compile("\\)(.*)").matcher(expr)).find();
String remainder = m.group(1);
int length = save.length();
int rLength = remainder.length();
save = save.substring(0, length - (rLength));
expr = parseExpr(save);
int i = findInt(expr);
String value = Integer.toString(i);
expr = value + remainder;
(m = Pattern.compile("\\)(.*)").matcher(save)).find();
}
其中expr是要解析和分解并计算的字符串。这段代码来自我的parseExpression函数。 findInt（）只返回它在字符串中找到的第一个整数。
编辑：我必须使用正则表达式。答案 0 :(得分：0)
正则表达式对这种操作有点过头了。自JDK1.6起，您就可以使用内置的Javascript engine。尽可能尝试使用它。
使用ScriptEngine.eval(String)方法基本上可以实现如下。
ScriptEngineManager mgr = new ScriptEngineManager();
ScriptEngine engine = mgr.getEngineByName("JavaScript");
String foo = "((4+1)*1) + 5";
System.out.println(engine.eval(foo));
答案 1 :(得分：0)
以下正则表达式应该与括号组匹配，其中包含任何内容：
\\(.*\\)
注意：双反斜杠是因为Java转义字符，正则表达式实际上是“（。*）”，没有引号。
但是，您似乎正在尝试解析表达式，并且正则表达式不是正确的工具，因此您应该考虑使用解析器。确保括号平衡的事情不能通过正则表达式在Java中完成，因此很难确保表达式的正确性，甚至可能无法实现。
答案 2 :(得分：0)
基本上，使用正则表达式对你的意图是错误的，因为你正在处理嵌套结构，即递归。正则表达式无法执行此操作。为了解释这一点，你应该首先理解有限自动机（它是正则表达式下面的数据结构）除了它所处的状态之外没有内存，如果你有任意深度的嵌套，你需要一个任意大的自动机，与有限自动机的概念相冲突。
但是有一个非常简单的algorithm来完成你的工作。
答案 3 :(得分：0)
公共课T_1 {
String c[];
Stack<String> s1 = new Stack<String>();
Stack<String> s2 = new Stack<String>();
int top = 0;
/**
* Description:构造函数
*
* @param expression
* :表达式字符串
*/
public T_1(String expression) {
ArrayList<String> al = new ArrayList<String>();
char chare[] = expression.toCharArray();
int count = 0;
int i = 0;
int start = 0;
while (count < chare.length) {
if (!judgeNum(new String(new char[] { chare[count] }))) {
if (i != 0) {
char c1[] = new char[i];
System.arraycopy(chare, start, c1, 0, i);
al.add(new String(c1));
}
al.add(new String(new char[] { chare[count] }));
i = 0;
start = count + 1;
} else {
i++;
}
count++;
}
if (judgeNum(new String(new char[] { chare[--count] }))) {
al.add(new String(new char[] { chare[count] }));
}
// c=(String[])(al.toArray());
System.out.println(al.toString());
c = new String[al.size()];
i = 0;
for (Object o : al.toArray()) {
c[i++] = o.toString();
}
}
/**
* Description:转换,c为中缀表达式
*/
public void transition() {
int i = 0;
while (i < c.length) {
if (s1.empty()) {
s1.push(c[i]);
} else {
if (judgeNum(c[i])) {
s1.push(c[i]);
} else if (judgeOperate(c[i])) {
if (s2.isEmpty()) {
s2.push(c[i]);
} else if (judgeLP(s2.peek())) {
s2.push(c[i]);
} else if (judgePriority(c[i], s2.peek())) {
s2.push(c[i]);
} else {
s1.push(s2.pop());
while (!s2.isEmpty() && !s2.peek().equals("(")) {
if (!judgePriority(c[i], s2.peek())) {
s1.push(s2.pop());
} else {
break;
}
}
s2.push(c[i]);
}
} else if (judgeLP(c[i])) {
s2.push(c[i]);
} else if (judgeRP(c[i])) {
while (true) {
String c_1 = s2.pop();
if (!judgeLP(c_1)) {
s1.push(c_1);
System.out.println("c_1" + c_1);
} else {
break;
}
}
}
}
i++;
}
while (!s2.isEmpty()) {
String c_1 = s2.pop();
if (!judgeLP(c_1)) {
s1.push(c_1);
}
}
}
/**
*
* @param c
* @return:是否是数字
*/
public boolean judgeNum(String c) {
try {
Integer.parseInt(c);
return true;
} catch (Exception e) {
return false;
}
}
/**
*
* @param c
* @return:是否是运算符
*/
public boolean judgeOperate(String c) {
if (c.equals("+") || c.equals("-") || c.equals("*") || c.equals("/")) {
return true;
}
return false;
}
/**
*
* @param c
* @return:是否是左括号
*/
public boolean judgeLP(String c) {
if (c.equals("(")) {
return true;
}
return false;
}
/**
*
* @param c
* @return:是否是右括号
*/
public boolean judgeRP(String c) {
if (c.equals(")")) {
return true;
}
return false;
}
/**
*
* @param a
* @param b
* @return:是否a的优先级大于b
*/
public boolean judgePriority(String a, String b) {
if ((a.equals("*") || a.equals("/"))
&& (b.equals("+") || b.equals("-"))) {
return true;
}
return false;
}
/**
* 运算
*/
public void operate() {
while (!s1.isEmpty()) {
s2.push(s1.pop());
}
/*
* while(!judgeNum(s2.peek())){ s1.push(s2.pop()); }
*/
System.out.println(s1.toString());
System.out.println(s2.toString());
while (!s2.isEmpty()) {
String s = s2.pop();
if (judgeNum(s)) {
s1.push(s);
} else {
String a = s1.pop();
String b = s1.pop();
s1.push(operate_(b, a, s));
System.out.println(s1.peek());
}
}
System.out.println(s1.pop());
}
public String operate_(String a, String b, String c) {
int ia = Integer.parseInt(a);
int ib = Integer.parseInt(b);
if (c.equals("+")) {
return String.valueOf(ia + ib);
} else if (c.equals("-")) {
return String.valueOf(ia - ib);
} else if (c.equals("*")) {
return String.valueOf(ia * ib);
} else if (c.equals("/")) {
return String.valueOf(ia / ib);
}
return "";
}
public static void main(String[] args) {
String s = JOptionPane.showInputDialog("请输入表达式!");
T_1 t = new T_1(s);// "1+2+3*1+(2-1*4)*2+2"
t.transition();
t.operate();
}
}