[4기 - 김영훈] 1~2주차 과제: 계산기 구현 미션 제출합니다.

build.gradle

@@ -13,6 +13,7 @@ dependencies {
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
     testImplementation 'org.assertj:assertj-core:3.24.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-params:5.9.2'
 }
 
 test {

src/main/java/CalculatorApplication.java

@@ -0,0 +1,13 @@
+import computation.PostfixComputer;
+import computation.PostfixConverter;
+import io.Calculator;
+import repository.CalculatorHistoryRepository;
+
+import java.io.IOException;
+
+public class CalculatorApplication {
+    public static void main(String[] args) throws IOException {
+        Calculator calculator = new Calculator(new PostfixConverter(), new PostfixComputer(), new CalculatorHistoryRepository());
+        calculator.runApplication();
+    }
+}

src/main/java/computation/Converter.java

@@ -0,0 +1,7 @@
+package computation;
+
+import java.util.List;
+
+public interface Converter {
+    List<String> convert(String expression);
+}

src/main/java/computation/Operator.java

@@ -0,0 +1,35 @@
+package computation;
+
+import exception.ZeroDivisionException;
+import java.util.Arrays;
+import java.util.function.BiFunction;
+
+public enum Operator {
+    ADD("+", (num1, num2) -> num1 + num2),
+    SUBTRACT("-", (num1, num2) -> num1 - num2),
+    MULTIPLY("*", (num1, num2) -> num1 * num2),
+    DIVIDE("/", (num1, num2) -> {
+        if (num2 == 0)
+            throw new ZeroDivisionException();
+        return num1 / num2;
+    });
+
+    private final String operator;
+    private final BiFunction<Integer, Integer, Integer> expression;
+
+    Operator(String operator, BiFunction<Integer, Integer, Integer> expression) {
+        this.operator = operator;
+        this.expression = expression;
+    }
+
+    public static Operator getOperator(String getString) {
+        return Arrays.stream(Operator.values())
+                .filter(s -> s.operator.equals(getString))
+                .findFirst()
+                .get();
+    }
+
+    public int operate(Integer num1, Integer num2) {
+        return expression.apply(num1, num2);
+    }
+}

src/main/java/computation/PostfixComputer.java

@@ -0,0 +1,25 @@
+package computation;
+
+import validation.Validator;
+
+import java.util.List;
+import java.util.Stack;
+
+public class PostfixComputer {
+    public int calculate(List<String> postfixExpression) {
+        Stack<Integer> calculationStack = new Stack<>();
+
+        for (String item : postfixExpression) {
+            if (Validator.isNumber(item)) {
+                calculationStack.push(Integer.parseInt(item));
+            } else if (Validator.isOperator(item)) {
+                Integer operand2 = calculationStack.pop();
+                Integer operand1 = calculationStack.pop();
+
+                Operator operator = Operator.getOperator(item);
+                calculationStack.push(operator.operate(operand1, operand2));
+            }
+        }
+        return calculationStack.pop();
+    }
+}

src/main/java/computation/PostfixConverter.java

@@ -0,0 +1,76 @@
+package computation;
+
+import validation.Validator;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+
+public class PostfixConverter implements Converter {
+    private final StringBuilder sb = new StringBuilder();
+    private final Map<String, Integer> priority = Map.of(
+            "(", 0,
+            "+", 1,
+            "-", 1,
+            "*", 2,
+            "/", 2
+    );
+
+    private boolean checkHigherPriority(Stack<String> operatorStack, String item) {
+        return priority.get(operatorStack.peek()) >= priority.get(item);
+    }
+
+    public void addElement(List<String> list) {
+        if (sb.length() > 0) {
+            list.add(sb.toString());
+            sb.setLength(0);
+        }
+    }
+
+    @Override
+    public List<String> convert(String expression) {
+        List<String> postfix = new ArrayList<>();
+
+        Stack<String> operatorStack = new Stack<>();
+        String[] infixArray = expression.split("");
+        sb.setLength(0);
+
+        for (int i = 0; i < infixArray.length; i++) {
+            // 숫자라면 단순히 추가
+            if (Validator.isNumber(infixArray[i])) {
+                sb.append(infixArray[i]);
+
+                if (i == infixArray.length - 1) {
+                    postfix.add(sb.toString());
+                }
+            } else {
+                addElement(postfix);
+
+                if (Validator.isOperator(infixArray[i])) {
+                    // 연산자라면 먼저 우선순위 계산
+                    if (!operatorStack.isEmpty()) {
+                        while (!operatorStack.isEmpty() && checkHigherPriority(operatorStack, infixArray[i])) {
+                            postfix.add(operatorStack.pop());
+                        }
+                    }
+                    operatorStack.push(infixArray[i]);
+                } else if (Validator.isOpenBrackets(infixArray[i])) {
+                    operatorStack.push(infixArray[i]);
+                } else if (Validator.isCloseBrackets(infixArray[i])) {
+                    // 괄호에 대한 처리
+                    while (!operatorStack.isEmpty()) {
+                        String poppedItem = operatorStack.pop();
+                        if (Validator.isOpenBrackets(poppedItem)) break;
+                        postfix.add(poppedItem);
+                    }
+                }
+            }
+        }
+
+        while (!operatorStack.isEmpty()) {
+            postfix.add(operatorStack.pop());
+        }
+        return postfix;
+    }
+}

src/main/java/exception/ZeroDivisionException.java

@@ -0,0 +1,8 @@
+package exception;
+
+public class ZeroDivisionException extends RuntimeException {
+    private static final String MESSAGE = "0으로는 나눌 수 없습니다.";
+    public ZeroDivisionException() {
+        super(MESSAGE);
+    }
+}

src/main/java/io/Calculator.java

@@ -0,0 +1,86 @@
+package io;
+
+import computation.Converter;
+import computation.PostfixComputer;
+import exception.ZeroDivisionException;
+import repository.Repository;
+import util.StringUtil;
+import validation.Validator;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Calculator {
+    private final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private final Converter converter;
+    private final PostfixComputer calculator;
+    private final Repository repository;
+
+    public Calculator(Converter converter, PostfixComputer calculator, Repository repository) {
+        this.converter = converter;
+        this.calculator = calculator;
+        this.repository = repository;
+    }
+
+    public void printMenu() {
+        System.out.println(MenuMessage.SELECT.getMessage());
+        System.out.println(MenuMessage.CALCULATION.getMessage());
+        System.out.println(MenuMessage.EXIT.getMessage());
+        System.out.print(MenuMessage.CHOOSE.getMessage());
+    }
+
+    public String getUserInput() throws IOException {
+        return br.readLine();
+    }
+
+    public void runInquiry() {
+        System.out.println(DisplayMessage.SPLIT_LINE.getMessage());
+        repository.inquiry();
+        System.out.println(DisplayMessage.SPLIT_LINE.getMessage());
+    }
+
+    public void runCalculator() throws IOException {
+        String getInput = StringUtil.removeWhiteSpace(getUserInput());
+        if (!Validator.isRightExpression(getInput)) {
+            System.out.println(DisplayMessage.WRONG_EXPRESSION.getMessage());
+            return;
+        }
+
+        try {
+            int result = calculator.calculate(converter.convert(getInput));
+            repository.save(getInput, result);
+            System.out.print(DisplayMessage.OUTPUT.getMessage());
+            System.out.println(result);
+        } catch (ZeroDivisionException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+
+    public void runApplication() throws IOException {
+        while (true) {
+            printMenu();
+
+            String getChoice = getUserInput();
+            if (Validator.isNotNumber(getChoice)) {
+                System.out.println(DisplayMessage.BAD_REQUEST.getMessage());
+                continue;
+            }
+
+            int choice = Integer.parseInt(getChoice);
+            if (choice == Menu.QUERY.getMenuNumber()) {
+                // 조회
+                runInquiry();
+            } else if (choice == Menu.CALCULATE.getMenuNumber()) {
+                // 계산
+                runCalculator();
+            } else if (choice == Menu.EXIT.getMenuNumber()) {
+                // 종료
+                System.exit(0);
+            } else {
+                System.out.println(DisplayMessage.BAD_REQUEST.getMessage());
+            }
+        }
+    }
+}