kth/계산기 1차 코드 리뷰

src/main/java/accumulator/PostFixAccumulator.java

@@ -4,13 +4,10 @@
 
 import java.util.Stack;
 import operator.Operator;
+import util.PatternValidator;
 
 public class PostFixAccumulator implements Accumulator {
 
-//  private static final String PLUS = "+";
-//  private static final String MINIS = "-";
-//  private static final String MULTIPLY = "*";
-//  private static final String DIVIDE = "/";
   private int firstOperand;
   private int secondOperand;
 
@@ -19,32 +16,50 @@ public int calculate(String postfixExpression) {
     Stack<Integer> result = new Stack<>();
     String[] splitPostfixExpression = postfixExpression.split(" ");
     for (String str : splitPostfixExpression) {
-      Operator value = stringToOperator(str);
-      switch (value) {
-        case PLUS:
-          firstOperand = result.pop();
-          secondOperand = result.pop();
-          result.push(secondOperand + firstOperand);
-          break;
-        case MINUS:
-          firstOperand = result.pop();
-          secondOperand = result.pop();
-          result.push(secondOperand - firstOperand);
-          break;
-        case MULTIPLY:
-          firstOperand = result.pop();
-          secondOperand = result.pop();
-          result.push(secondOperand * firstOperand);
-          break;
-        case DIVIDE:
-          firstOperand = result.pop();
-          secondOperand = result.pop();
-          result.push(secondOperand / firstOperand);
-          break;
-        default:
-          result.push(Integer.parseInt(value));
-      }
+      processToken(result, str);
     }
     return result.pop();
   }
+
+  private void processToken(Stack<Integer> result, String str) {
+    if(PatternValidator.checkOperatorValue(str)){
+      processOperator(result, str);
+    } else if (!PatternValidator.checkOperatorValue(str)) {
+      processOperand(result, str);
+    }
+  }
+
+  private void processOperand(Stack<Integer> result, String str) {
+    result.push(Integer.parseInt(str));
+  }
+
+  private void processOperator(Stack<Integer> result, String str) {
+    Operator value = stringToOperator(str);
+    calculate(result, value);
+  }
+
+  private void calculate(Stack<Integer> result, Operator value) {
+    switch (value) {
+      case PLUS:
+        firstOperand = result.pop();
+        secondOperand = result.pop();
+        result.push(secondOperand + firstOperand);
+        break;
+      case MINUS:
+        firstOperand = result.pop();
+        secondOperand = result.pop();
+        result.push(secondOperand - firstOperand);
+        break;
+      case MULTIPLY:
+        firstOperand = result.pop();
+        secondOperand = result.pop();
+        result.push(secondOperand * firstOperand);
+        break;
+      case DIVIDE:
+        firstOperand = result.pop();
+        secondOperand = result.pop();
+        result.push(secondOperand / firstOperand);
+        break;
+    }
+  }
 }

src/main/java/convertor/InfixToPostfixConverter.java

@@ -3,35 +3,55 @@
 import java.util.Arrays;
 import java.util.Stack;
 import operator.Operator;
+import util.PatternValidator;
 
 public class InfixToPostfixConverter {
 
-  private String postfix = "";
+  private StringBuilder postfix = new StringBuilder();
+
 
   public String changeToPostFix(String expression) {
     Stack<String> operatorStack = new Stack();
     String[] splitExpression = expression.split(" ");
-    Arrays.stream(splitExpression).forEach(str -> {
-      Operator operator = Operator.stringToOperator(str);
-      int operatorPriority = operatorPriority(operator);
-      int value = Integer.parseInt(str);
-      if (operatorPriority == -1) {
-        postfix += value + " ";
-      } else if (operatorStack.isEmpty()) {
-        operatorStack.add((value + " "));
-      } else {
-        while (!operatorStack.isEmpty()
-            && operatorPriority(Operator.stringToOperator(operatorStack.peek().substring(0, 1)))
-            >= operatorPriority) {
-          postfix += operatorStack.pop();
-        }
-        operatorStack.add((value + " "));
-      }
+    Arrays.stream(splitExpression).forEach(token -> {
+      processToken(operatorStack, token);
     });
     while (!operatorStack.isEmpty()) {
-      postfix += operatorStack.pop();
+      postfix.append(operatorStack.pop());
+    }
+    return postfix.toString();
+  }
+
+  private void processToken(Stack<String> operatorStack, String token) {
+    if (PatternValidator.checkOperatorValue(token)) {
+      handleOperator(operatorStack, token);
+    } else if (!PatternValidator.checkOperatorValue(token)) {
+      handelOperand(token);
+    }
+  }
+
+  private void handelOperand(String token) {
+    int value = Integer.parseInt(token);
+    postfix.append(value).append(" ");
+  }
+
+  private void handleOperator(Stack<String> operatorStack, String token) {
+    Operator currentOperator = Operator.stringToOperator(token);
+    int currentOperatorPriority = operatorPriority(currentOperator);
+    setOperatorToOperatorStack(operatorStack, token,currentOperatorPriority);
+  }
+
+  private void setOperatorToOperatorStack(Stack<String> operatorStack, String token,int currentOperatorPriority) {
+    compareOperatorPriority(operatorStack,currentOperatorPriority);
+    operatorStack.add((token + " "));
+  }
+
+  private void compareOperatorPriority(Stack<String> operatorStack,int currentOperatorPriority) {
+    Operator topStackOperator = Operator.stringToOperator(operatorStack.peek().substring(0, 1));
+    int topStackOperatorPriority = operatorPriority(topStackOperator);
+    while (!operatorStack.isEmpty() && topStackOperatorPriority >= currentOperatorPriority) {
+      postfix.append(operatorStack.pop());
     }
-    return postfix;
   }