解析多位数算术表达式的有效方法

Question

For example, suppose I have a string expression "10.2*(8-6)/3+112.5"

I need to insert the number to a List and operator to a different List

My current (ugly) approach:

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;


public class Test {



    public static void main (String args[]) 
    {
        String expression = "10.2*(8-6)/3+112.5"; 
        List<Character> firstList = new ArrayList<Character>();
        List<String> secondList = new ArrayList<String>();

         // Temporary string to hold the number
        StringBuilder temp = new StringBuilder();

        for(int i = 0; i != expression.length(); ++i)
        {           
            if(Character.isDigit(expression.charAt(i)))
            {
                /* If we encounter a digit, read all digit next to it and append to temp
                 * until we encounter an operator.
                 */
                temp.append(expression.charAt(i));

                while((i+1) != expression.length() && (Character.isDigit(expression.charAt(i+1)) 
                                                  || expression.charAt(i+1) == '.'))
                {
                    temp.append(expression.charAt(++i));
                }

                // Next token is either an operator or end of expression
                // Put the number into the list and clear temp for next number
                secondList.add(temp.toString());
                temp.delete(0, temp.length());
            }
            // Getting here means the token is an operator
            else
                firstList.add(expression.charAt(i));
        }

        System.out.print("Numbers: ");
        for(String str : secondList)
            System.out.print(str + " ");

        System.out.println();
        System.out.print("Operators: ");
        for(Character ch  : firstList)
            System.out.print(ch.toString() + " ");
    }   
}

Test run:

Numbers: 10.2 8 6 3 112.5 
Operators: * ( - ) / + 

It somewhat works, but I'm sure there are cleaner, more efficient approach. Thanks in advance!

Answer 1

I would create a list containing all operations to check it later:

List<Character> operations = new ArrayList<Character>();
operations.add('*'); // put all operations * / ( ) etc...

and optimize the way you check decimal numbers:

while (!operations.contains(expression.charAt(i)) && i < (expression.length()-1)) 
                    i++;     
secondList.add(expression.substring(c, i));

Then, when you get the Character from the String, simply check:

for(int i = 0; i != expression.length(); ++i) {
    if (operations.contains(expression.charAt(i))) {
        firstList.add(expression.charAt(i));
    } else {
        int c = i;
        while (!operations.contains(expression.charAt(i)) && i < (expression.length()-1)) 
                i++; 

        secondList.add(expression.substring(c, i));
        if (i < (expression.length()-1)) i--;
    }
}

Check a working demo here

Answer 2

You could also use basic regular expression matching to separate operands from operators in the expression you want to parse.

Here's a working example of that using the regular expression [^\\*\\-\\(\\)\\/\\+]+ . You'll find a detailed explanation of the regular expression used after the code and the idea behind the code as inline comments.

import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ArithmeticExpressionParser 
{
    public void parse(String expression, List<Character> operatorList, 
            List<String> operandList)
    {
        // Create a string of (escaped) operators. Just append all other 
        // operators that you may need.
        StringBuffer operators = new StringBuffer();
        operators.append("\\*");  // *
        operators.append("\\-");  // -
        operators.append("\\(");  // (
        operators.append("\\)");  // )
        operators.append("\\/");  // /
        operators.append("\\+");  // +

        // Compile and match a regular expression matching sequences of
        // non-operator characters against the given expression.
        Pattern pattern = Pattern.compile("[^" + operators + "]+");
        Matcher matcher = pattern.matcher(expression);

        // For each matched subsequence (which represents an operand)...
        int previousEnd = 0;
        while(matcher.find()) {

            // ... add all the operator characters between the end of the last
            // match and the beginning of this match to the operator list ...
            for (int i=previousEnd; i<matcher.start(); i++) {
                operatorList.add(expression.charAt(i));
            }

            // ... and the current match to the operand list.
            operandList.add(
                    expression.substring(matcher.start(), matcher.end()));

            previousEnd = matcher.end();
        }
    }
}

Explanation of the regular expression: The brackets just group a set of characters, in this case all the operators. The ´^´ means that the group should contain all characters BUT the ones mentioned afterwards, so this group actually means "all non-operator characters". The operators mentioned afterwards are escaped by a \\ because otherwise they would be interpreted as special characters inside the regular expression. Finally with the non-escaped ´+´ after the bracket we indicate that we want to match sequences of one or more of the characters inside the bracket. Because we give the regular expression as a java string we actually need to escape twice, because \\ has to be escaped inside java strings.