使用Java处理负数时拆分数学表达式

我正在用Java开发一个表达式计算器。我决定先写一个转换成后缀的代码，然后写一个反向波兰符号计算器。到目前为止，我的计算器工作得很好，可以处理任何表达式，包括运算符

+-*/%

但是，我遇到的问题是，它使用空格

输入分割表达式。分割（“”

），因此这意味着必须输入表达式

（4+（2*（-2-1））*1.5

，然后才能输入

（4+（2*（-2-1））*1.5

经过几个小时的修补，我现在知道它不能工作正则表达式，但它是否能够编写一个for循环，一次遍历字符串的两个标记，如果它们都等于一个运算符，那么可以假设第二个必须是负值。或者，如果方程以运算符开头，那么它一定是负值？像这样迭代字符串，直到第二个运算符到达表达式的末尾

下面是一些我一直在玩的代码，我想从这里开始，但由于我对编程还是很陌生，我似乎无法让它工作

String expression = "(4+(2*(-2--16)))*-1.5";
ArrayList<String> tokens = new ArrayList<String>();
String orig = null;
String regex = "[-+/*()]+";
String first = Character.toString(expression.charAt(0));
tokens.add(first);
for (int i = 0; i < expression.length(); i++) {
    char x = expression.charAt(i);
    String a = Character.toString(x);
    if (i >= 1){    //Check i is greater than or equal to 1
        char y = expression.charAt(i-1);
        String b = Character.toString(y);
        if(b.matches(regex) && x == '-'){
            orig = a;
        }else if(orig != null && orig.equals("-")){
            System.out.println(orig + a);
            tokens.add(orig + a);
            orig = null;
        }else{
            tokens.add(a);
        }
    }
}
for(String t:tokens){
    System.out.print(t+" ");
}

String expression=“（4+（2*（-2-16）））*-1.5”；
ArrayList标记=新的ArrayList（）；
字符串orig=null；
字符串regex=“[-+/*（）]”；
字符串优先=Character.toString（expression.charAt（0））；
代币。添加（第一）；
for（int i=0；i=1）{//检查i是否大于或等于1
chary=表达式charAt（i-1）；
字符串b=字符。toString（y）；
如果（b.matches（regex）&&x='-'）{
orig=a；
}else if（orig！=null&&orig.equals（“-”）{
系统输出打印项次（原+a）；
代币。添加（原币+a）；
orig=null；
}否则{
代币。添加（a）；
}
}
}
for（字符串t：令牌）{
系统输出打印（t+“”）；
}

谢谢你的帮助，西亚兰

编辑：

我的问题是，我如何编写一个方法来拆分一个数学表达式，在拆分时，它可以区分作为二元运算符的“-”和作为一元运算符的“-”的区别？我对遍历字符串并比较两个标记的想法是否正确Ciaran Ashton 6分钟前

我正在努力实现的目标

---

我想把

字符串表达式=（4+（2*（-2-1））

转换成

字符串[]表达式=（，4，（，2，*，（，-2，-，1，），），）

这是一个合适的工作。Java世界中最著名的是和。我喜欢与JavaCC搭配使用

---

它们的好处在于，您根据上下文赋予标记不同的含义。因此，负号在一个地方可能意味着一件事，而在另一个地方可能意味着另一件事。

这是一份合适的工作。Java世界中最著名的是和。我喜欢与JavaCC搭配使用

---

它们的好处在于，您根据上下文赋予标记不同的含义。因此，负号可以在一个地方表示一件事，在另一个地方表示另一件事。

使用解析器是更好的解决方案，但要回答您提出的问题，您可以使用这个正则表达式，它几乎可以满足您的需要（不是100%，而是很接近）：

输出：

[7, +, 4, -, (, 18, /, 3, ), /, 2, a, ^, 222, +, 1, a, b]

在此处查看它的实际操作：

---

使用解析器是更好的解决方案，但要回答您提出的问题，您可以使用这个正则表达式，它几乎可以满足您的需要（不是100%，而是很接近）：

输出：

[7, +, 4, -, (, 18, /, 3, ), /, 2, a, ^, 222, +, 1, a, b]

在此处查看它的实际操作：

---

这是一个只使用正则表达式的版本。它与示例输入匹配，但不会处理一元运算符放在括号前面或嵌套多个一元运算符的情况（例如“-1”）：

//匹配标准Java数字格式的表达式
//例如1234、12.5和1.3E-19
字符串编号=“\\d+（？：\.\\d+（？：（？：E|E）-？\\d+”；
//符合以下条件的表达式：
//数
//带一元运算符的数字（如果前面有（、-、+、/、或*），则视为一元数）
//（，），-，+，/，或*
String token=“（“+number+”|）（？这是一个仅使用正则表达式的版本。它与示例输入匹配，但不会处理一元运算符放在括号前面或嵌套多个一元运算符的情况（例如“-1”）：

//匹配标准Java数字格式的表达式
//例如1234、12.5和1.3E-19
字符串编号=“\\d+（？：\.\\d+（？：（？：E|E）-？\\d+”；
//符合以下条件的表达式：
//数
//带一元运算符的数字（如果前面有（、-、+、/、或*），则视为一元数）
//（，），-，+，/，或*
String token=“（“+number+”|）（？这可能是您的问题和类似问题的解决方案，尽管我没有在各种数据上对此进行彻底测试，但方法是——每当一元运算符出现在表达式（完全圆括号表达式）中时，它的前面会有“（”，后面会有一个数字

    String expression = "(4+(2*(-2-1)))*1.5";
    List<String> tokens = new ArrayList<String>();
    String prev = null;
    int c = 0;
    for (int i = 0; i < expression.length(); i++) {
        char x = expression.charAt(i);
        String a = Character.toString(x);
        if (i >= 1 && expression.charAt(i - 1) == '(' && x == '-') {
            prev = a;
        } else {
            if (prev != null && prev.equals("-")) {
                tokens.add(prev + a);
                prev = null;
            } else {
                tokens.add(a);
            }
            c++;
        }
    }

String expression=“（4+（2*（-2-1）））*1.5”；
List tokens=new ArrayList（）；
字符串prev=null；
int c=0；
for（int i=0；i=1&&expression.charAt（i-1）='（'&&x=='-'））{
prev=a；
}否则{
if（prev！=null&&prev.equals（“-”）{
代币。添加（上一个+a）；
prev=null；
}否则{
代币。添加（a）；
}
C++；
}
}
这可以解决您的问题和类似的问题，尽管我还没有对各种数据进行彻底测试，但方法是——无论何时表达式（全括号表达式）中出现一元运算符，它的前面都会有“（”和后面的数字

    String expression = "(4+(2*(-2-1)))*1.5";
    List<String> tokens = new ArrayList<String>();
    String prev = null;
    int c = 0;
    for (int i = 0; i < expression.length(); i++) {
        char x = expression.charAt(i);
        String a = Character.toString(x);
        if (i >= 1 && expression.charAt(i - 1) == '(' && x == '-') {
            prev = a;
        } else {
            if (prev != null && prev.equals("-")) {
                tokens.add(prev + a);
                prev = null;
            } else {
                tokens.add(a);
            }
            c++;
        }
    }

String expression=“（4+（2*（-2-1）））*1.5”；
列表令牌=新的
// expression that matches standard Java number formats
// such as 1234, 12.5, and 1.3E-19
String number = "\\d+(?:\\.\\d+(?:(?:E|e)-?\\d+)?)?";
// expression that matches : 
// number
// number with unary operator (deemed unary if preceded by (,-,+,/, or *)
// (,),-,+,/, or *
String token = "(" + number + "|(?<=[(-+/*])-" + number + "|[-+/*()])?";
Pattern p = Pattern.compile(token);
Matcher m = p.matcher("(4+(2*(-2-1)))*1.5");
while (m.find()) {
  System.out.println(m.group(0));
}

    String expression = "(4+(2*(-2-1)))*1.5";
    List<String> tokens = new ArrayList<String>();
    String prev = null;
    int c = 0;
    for (int i = 0; i < expression.length(); i++) {
        char x = expression.charAt(i);
        String a = Character.toString(x);
        if (i >= 1 && expression.charAt(i - 1) == '(' && x == '-') {
            prev = a;
        } else {
            if (prev != null && prev.equals("-")) {
                tokens.add(prev + a);
                prev = null;
            } else {
                tokens.add(a);
            }
            c++;
        }
    }

import java.util.ArrayList;
import java.util.Arrays;


public class expSplit {

    public String[] splitExp(String theexp){
        ArrayList<String> tokens = new ArrayList<String>();
        //System.out.println(theexp);
        String expression = theexp.replaceAll("\\s+", "");
        //System.out.println(expression);
        String tem[] = expression.split("(?<=[-+*/%(),])(?=.)|(?<=.)(?=[-+*/%(),])");
        ArrayList<String> temp = new ArrayList<String>(Arrays.asList(tem));
        String orig = null;
        String regex = "[-+/%*]+";
        String first = temp.get(0);
        tokens.add(first);
        String secound = temp.get(1);
        if(first.equals("-")){
            tokens.remove(0);
            tokens.add(first+secound);
        }
        for (int i = 0; i < temp.size(); i++) {
            String a = temp.get(i);
            if (i >= 1){
                String b = temp.get(i-1);
                if(b.matches(regex) && a.matches("[-+]+")){
                    String c = temp.get(i-2);
                    if(c.matches("[-+]+")){
                        //System.out.println("MATCH");
                        break;
                    }else{
                        //System.out.println("NO MATCH");
                        orig = a;
                    }
                }else if(orig != null && orig.equals("-")){
                    tokens.add(orig + a);
                    orig = null;
                }else{
                    tokens.add(a);
                }
            }
        }
        if(first.equals("+")){
            tokens.remove(0);
        }
        if(first.equals("-")){
            tokens.remove(1);
        }
        String[]tokenArray = new String[tokens.size()];
        tokenArray = tokens.toArray(tokenArray);
        //System.out.print(tokens);
        return tokenArray;
    }
}