Hyunje

README.md

@@ -1 +1,38 @@
 # Calculator
+
+## 📌 구현 기능 목록
+
+### 입력받기
+
+"수식을 입력해주세요." ← 사용자에게 문구 출력
+
+입력 받기
+
+### 로직
+
+#### 입력 검사
+
+##### 통과
+
+- 공백은 0
+- 연산방향은 왼쪽에서 오른쪽  
+- (연산자 우선순위)
+
+##### 에러
+
+`IllegalArgumentException`
+
+- 연속된 연산자
+- 타입 에러
+
+
+
+### 출력
+
+#### 정상 출력
+
+"결과 : ?"
+
+#### 에러 발생
+
+"[ERROR] 잘못된 수식입니다. 입력 형식을 확인해 주세요."

src/main/java/calculator/Application.java

@@ -1,11 +1,35 @@
 package calculator;
 
+import java.util.ArrayList;
+
 public class Application {
+
+    private static final Console console = new Console();
+
     public static void main(String[] args) {
-        // TODO: 코드 작성
+        String inputString = console.readInput();
+
+        run(inputString);
+    }
 
-        // 예시 코드
+    public static int run(String inputString) {
+        Validator validator = new Validator();
         Calculator calculator = new Calculator();
-        calculator.calculate("");
+
+        ArrayList<String> inputArrayList;
+        int result = 0;
+
+        try {
+            inputArrayList = validator.divideInput(inputString);
+            result = calculator.calculate(inputArrayList);
+        } catch (IllegalStateException e) {
+            // 입력값이 공백값 또는 비어있는 경우
+        } catch (IllegalArgumentException illegalArgumentException) {
+            System.out.println(illegalArgumentException.getMessage());
+            return -1;
+        }
+
+        console.printResult(result);
+        return result;
     }
 }

src/main/java/calculator/Calculator.java

@@ -1,13 +1,55 @@
 package calculator;
 
-/*
-    1주차에만 제공되는 예시 코드입니다.
-    코드는 그대로 사용해도 되고 수정해도 됩니다.
- */
+import java.util.*;
 
+// 연산 책임
 public class Calculator {
-    public int calculate(String input) {
-        // TODO: 코드 구현
-        throw new IllegalArgumentException("아직 구현되지 않았습니다.");
+
+    private int result = 0;
+
+    public int calculate(ArrayList<String> inputArrayList) {
+
+        // 단일 원소인 경우 그대로 return
+        if (isSingleElement(inputArrayList)) {
+            return Integer.parseInt(inputArrayList.get(0));
+        }
+
+        // 큐 선언
+        LinkedList<String> stringQueue = toQueue(inputArrayList);
+
+        while (stringQueue.size() > 1) {
+
+            result = operate(
+                    stringQueue.poll(),
+                    stringQueue.poll(),
+                    stringQueue.poll()
+            );
+
+            stringQueue.addFirst(String.valueOf(result));
+        }
+
+        return result;
+    }
+
+
+    private boolean isSingleElement(ArrayList<String> inputArrayList) {
+        return inputArrayList.size() == 1;
+    }
+
+    private LinkedList<String> toQueue(ArrayList<String> inputArrayList) {
+        return new LinkedList<>(inputArrayList);
+    }
+
+    private int operate(String num1String, String operator, String num2String) {
+        int num1 = Integer.parseInt(num1String);
+        int num2 = Integer.parseInt(num2String);
+
+        return switch (operator) {
+            case "+" -> num1 + num2;
+            case "-" -> num1 - num2;
+            case "*" -> num1 * num2;
+            case "/" -> num1 / num2;
+            default -> throw new IllegalStateException("Unexpected value: " + operator);
+        };
     }
 }

src/main/java/calculator/Console.java

@@ -0,0 +1,26 @@
+package calculator;
+
+import java.util.Scanner;
+
+// TODO: SINGLETON?
+// 입출력 책임
+public class Console {
+    private static final String MESSAGE_INPUT_GUIDE = "수식을 입력해주세요.";
+    private static final String MESSAGE_OUTPUT_FORMATTED = "결과 : %d";
+
+    public static final String MESSAGE_ERROR_FORMAT = "[ERROR] 잘못된 수식입니다. 입력 형식을 확인해 주세요.";
+    public static final String MESSAGE_ERROR_WRONG_POSITION_OPERATORS = "[ERROR] 잘못된 연산자 위치입니다. 입력 형식을 확인해 주세요.";
+    public static final String MESSAGE_ERROR_EMPTY_OR_BLANK = "[ERROR] 입력값이 없거나 공백입니다. 입력 형식을 확인해 주세요.";
+
+
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public String readInput() {
+        System.out.println(MESSAGE_INPUT_GUIDE);
+        return scanner.nextLine();
+    }
+
+    public void printResult(int result) {
+        System.out.println(String.format(MESSAGE_OUTPUT_FORMATTED, result));
+    }
+}

src/main/java/calculator/Validator.java

@@ -0,0 +1,63 @@
+package calculator;
+
+import java.util.ArrayList;
+import java.util.Set;
+
+// 검사 책임
+
+public class Validator {
+
+    // 검사를 위한 배열 생성
+    private final ArrayList<String> inputArrayList = new ArrayList<>();
+    // 검사를 위한 연산자 set
+    private static final Set<Character> OPERATORS = Set.of('+', '-', '*', '/');
+
+    // 검사 이후 숫자와 연산자로 쪼개어 배열로 return
+    public ArrayList<String> divideInput(String input) {
+        String currentNumber = "";
+
+        validateEmptyOrBlank(input);
+
+        for (int i = 0; i < input.length(); i++) {
+            char ch = input.charAt(i);
+
+            if (Character.isDigit(ch)) {
+                currentNumber += ch;
+
+                validateLastNumber(i, input.length() - 1, currentNumber);
+
+            } else if (OPERATORS.contains(ch)) {
+                validateOperatorPosition(currentNumber);
+
+                inputArrayList.add(currentNumber);
+                inputArrayList.add(String.valueOf(ch));
+
+                currentNumber = "";
+
+            } else {  // 숫자나 문자열이 아닌 경우
+                throw new IllegalArgumentException(Console.MESSAGE_ERROR_FORMAT);
+            }
+        }
+
+        return inputArrayList;
+    }
+
+    private void validateLastNumber(int position, int length, String currentNumber) {
+        if (position == length) {
+            inputArrayList.add(currentNumber);
+        }
+    }
+
+    private void validateEmptyOrBlank(String input) {
+        if (input.isBlank()) {
+            throw new IllegalStateException(Console.MESSAGE_ERROR_EMPTY_OR_BLANK);
+        }
+    }
+
+    private void validateOperatorPosition(String currentNumber) {
+        if (currentNumber.isEmpty()) {
+            throw new IllegalArgumentException(Console.MESSAGE_ERROR_WRONG_POSITION_OPERATORS);
+        }
+    }
+
+}

src/test/java/calculator/ApplicationTest.java

@@ -1,36 +1,31 @@
 package calculator;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+
 import org.junit.jupiter.api.Test;
 
+
 public class ApplicationTest {
-    Calculator calculator = new Calculator();
 
     @Test
     public void 빈_문자열_입력_시_0을_반환한다() {
-        // 아직 calculate 함수가 구현되지 않은 상태에서 TDD Red Test용 코드
-        int result = calculator.calculate("");
-        assertThat(result).isEqualTo(0);
+        assertThat(Application.run("   ")).isEqualTo(0);
     }
 
     @Test
     public void 덧셈과_뺄셈만_포함된_수식_계산() {
-        int result = calculator.calculate("1+2-3");
-        assertThat(result).isEqualTo(0);
+        assertThat(Application.run("1+2-3")).isEqualTo(0);
     }
 
     @Test
     public void 곱셈과_덧셈_포함_수식_계산() {
-        int result = calculator.calculate("2*3+4");
-        assertThat(result).isEqualTo(10);
+        assertThat(Application.run("2*3+4")).isEqualTo(10);
+
     }
 
     @Test
     public void 잘못된_수식_입력_시_예외_발생() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            calculator.calculate("1++2");
-        });
+        assertThat(Application.run("1++2")).isEqualTo(-1);
     }
 
     // TODO: 테스트 코드 추가 가능합니다.

src/test/java/calculator/CalculatorTest.java

@@ -0,0 +1,53 @@
+package calculator;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class CalculatorTest {
+
+    Calculator calculator = new Calculator();
+
+    @Test
+    void calculate_test_single() {
+        ArrayList<String> input = new ArrayList<>(List.of("12"));
+        int result = calculator.calculate(input);
+
+        assertThat(result).isEqualTo(12);
+    }
+
+    @Test
+    void calculate_test_simple() {
+        ArrayList<String> input = new ArrayList<>(List.of("1", "+", "2"));
+        int result = calculator.calculate(input);
+
+        assertThat(result).isEqualTo(3);
+    }
+
+    @Test
+    void calculate_test_divide() {
+        ArrayList<String> input = new ArrayList<>(List.of("4", "/", "2"));
+        int result = calculator.calculate(input);
+
+        assertThat(result).isEqualTo(2);
+    }
+
+    @Test
+    void calculate_test_complex() {
+        ArrayList<String> input = new ArrayList<>(List.of("2", "+", "3", "*", "4"));
+        int result = calculator.calculate(input);
+
+        assertThat(result).isEqualTo(20);
+    }
+
+    @Test
+    void calculate_test_wrong_operator() {
+        ArrayList<String> input = new ArrayList<>(List.of("1", "&", "2"));
+
+        assertThrows(IllegalStateException.class, () -> calculator.calculate(input));
+    }
+}

src/test/java/calculator/ValidatorTest.java

@@ -0,0 +1,55 @@
+package calculator;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class ValidatorTest {
+
+    Validator validator = new Validator();
+
+    @Test
+    void split_test() {
+        String input = "3+5*2";
+        List<String> result = validator.divideInput(input);
+
+        assertThat(result).containsExactly("3", "+", "5", "*", "2");
+    }
+
+    @Test
+    void exception_test_for_blank() {
+        String input = "   ";
+        Exception e = assertThrows(IllegalStateException.class, () -> validator.divideInput(input));
+
+        assertThat(e.getMessage()).isEqualTo(Console.MESSAGE_ERROR_EMPTY_OR_BLANK);
+    }
+
+    @Test
+    void exception_test_for_operators() {
+        String input = "3++2";
+        Exception e = assertThrows(IllegalArgumentException.class, () -> validator.divideInput(input));
+
+        assertThat(e.getMessage()).isEqualTo(Console.MESSAGE_ERROR_WRONG_POSITION_OPERATORS);
+    }
+
+    @Test
+    void exception_test_for_input_format() {
+        String input = "5+a";
+        Exception e = assertThrows(IllegalArgumentException.class, () -> validator.divideInput(input));
+
+        assertThat(e.getMessage()).isEqualTo(Console.MESSAGE_ERROR_FORMAT);
+    }
+
+    @Test
+    void exception_test_for_first_starts_with_operator() {
+        String input = "+12+3-5";
+        Exception e = assertThrows(IllegalArgumentException.class, () -> validator.divideInput(input));
+
+        assertThat(e.getMessage()).isEqualTo(Console.MESSAGE_ERROR_WRONG_POSITION_OPERATORS);
+
+    }
+
+}