Step1 (#2998)

* docs: <1단계> 기능 요구 사항 정리

* docs: <1단계> 정수에 대한 사칙연산 기능 구현

* docs: <1단계> 수식에서 숫자, 연산자 분류 기능 구현

* docs: <1단계> Numbers 일급 콜렉션

* docs: <1단계> Operations 일급 콜렉션

* docs: <1단계> 둘 이상의 연산자 연산

* docs: <1단계> 사용자로부터 문자열 입력

* feat: <1단계> 피드백 반영

- 축약어 제거
- 상수와 변수 사이 공백 추가

* feat: <1단계> 피드백 반영

- 팩토리 패턴 도입
- stream 활용

* feat: <1단계> 피드백 반영

- Operator Enum 활용

* feat: <1단계> 피드백 반영

- Operator.calculate 메서드 시그니처 변경
- stream 활용

* feat: <1단계> 피드백 반영

- 메소드 네임 변경

* feat: <1단계> 피드백 반영

- StringCalculator 클래스 기능 분리

Author: gisungPark

README.md

@@ -6,4 +6,14 @@
 * 모든 피드백을 완료하면 다음 단계를 도전하고 앞의 과정을 반복한다.
 
 ## 온라인 코드 리뷰 과정
-* [텍스트와 이미지로 살펴보는 온라인 코드 리뷰 과정](https://github.com/next-step/nextstep-docs/tree/master/codereview)
+* [텍스트와 이미지로 살펴보는 온라인 코드 리뷰 과정](https://github.com/next-step/nextstep-docs/tree/master/codereview)
+
+## 기능 요구 사항
+- [x] 문자열로부터 공백으로 구분된 숫자와 연산자를 분류한다.    
+- [x] 덧셈 연산을 계산한다.  
+- [x] 뺄셈 연산을 계산한다.  
+- [x] 곱셈 연산을 계산한다.  
+- [x] 나눗셈 연산을 계신한다. (단, 정수로 떨어지는 경우로 한정한다.)   
+- [x] 둘 이상의 연산자가 존재할 경우, 앞에서부터 차례로 계산한다.  
+- [x] 숫자, 연산자에 대한 예외 처리를 한다.  
+- [x] 사용자로부터 문자열을 입력받는다.  

src/main/java/.gitkeep

@@ -0,0 +1,37 @@
+package domain;
+
+import view.InputView;
+
+public class CalculatorMain {
+    public static void main(String[] args) {
+
+        StringCalculator stringCalculator = new StringCalculator();
+
+        String expression = InputView.readExpression();
+        validExpression(expression);
+
+        System.out.println(">>> " + stringCalculator.calculate(readNumbers(expression), readOperators(expression)));
+    }
+
+    static void validExpression(String expression) {
+        if (expression == null || expression.isBlank()) {
+            throw new IllegalArgumentException("유효한 표현식이 아닙니다.");
+        }
+    }
+
+    static Operations readOperators(String expression) {
+        OperatorFactory operatorFactory = new OperatorFactory();
+        return new Operations(operatorFactory.extractList(splitByBlank(expression)));
+    }
+
+    static Numbers readNumbers(String expression) {
+        CalculatorTokenFactory numbersFactory = new NumbersFactory();
+        return new Numbers(numbersFactory.extractList(splitByBlank(expression)));
+    }
+
+    private static String[] splitByBlank(String expression) {
+        return expression.split(" ");
+    }
+
+
+}

src/main/java/domain/CalculatorMain.java

@@ -0,0 +1,7 @@
+package domain;
+
+import java.util.List;
+
+public interface CalculatorTokenFactory {
+    <T> List<T> extractList(String[] splits);
+}

src/main/java/domain/CalculatorTokenFactory.java

@@ -0,0 +1,36 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+
+public class Numbers {
+
+    private Deque<Integer> numbers;
+
+    public Numbers(List<Integer> numbers) {
+        this.numbers = new LinkedList<>(numbers);
+    }
+
+    public Integer getNextNumber() {
+        return numbers.pollFirst();
+    }
+
+    public List<Integer> getNumbers() {
+        return new ArrayList<>(numbers);
+    }
+
+    public void add(int element) {
+        numbers.addFirst(element);
+    }
+
+    public int size() {
+        return numbers.size();
+    }
+
+    public boolean isContain(Integer number) {
+        return numbers.contains(number);
+    }
+
+}

src/main/java/domain/Numbers.java

@@ -0,0 +1,21 @@
+package domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class NumbersFactory implements CalculatorTokenFactory {
+
+    @Override
+    public List<Integer> extractList(String[] splits) {
+        return IntStream.range(0, splits.length)
+                .filter(i -> isNumberPosition(i))
+                .mapToObj(i -> Integer.parseInt(splits[i]))
+                .collect(Collectors.toList());
+    }
+
+    private boolean isNumberPosition(int index) {
+        return index % 2 == 0;
+    }
+
+}

src/main/java/domain/NumbersFactory.java

@@ -0,0 +1,30 @@
+package domain;
+
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+
+public class Operations {
+
+    private Deque<Operator> operators;
+
+    public Operations(List<Operator> operators) {
+        this.operators = new LinkedList<>(operators);
+    }
+
+    public boolean hasNext() {
+        return !operators.isEmpty();
+    }
+
+    public Operator next() {
+        if (operators.isEmpty()) {
+            return null;
+        }
+        return operators.pollFirst();
+    }
+
+    public boolean isContain(Operator operator) {
+        return operators.contains(operator);
+    }
+
+}

src/main/java/domain/Operations.java

@@ -0,0 +1,34 @@
+package domain;
+
+import java.security.InvalidParameterException;
+import java.util.Arrays;
+import java.util.function.BiFunction;
+
+public enum Operator {
+    PLUS("+", (left, right) -> left + right),
+    SUBTRACT("-", (left, right) -> left - right),
+    MULTIPLY("*", (left, right) -> left * right),
+    DIVIDE("/", (left, right) -> left / right);
+
+    private String symbol;
+    private BiFunction<Integer, Integer, Integer> biFunction;
+
+    Operator(String symbol, BiFunction<Integer, Integer, Integer> biFunction) {
+        this.symbol = symbol;
+        this.biFunction = biFunction;
+    }
+
+    public Integer calculate(int left, int right) {
+        if (this == DIVIDE && right == 0) {
+            throw new InvalidParameterException("0으로 나눌 수 없습니다.");
+        }
+        return biFunction.apply(left, right);
+    }
+
+    public static Operator toOperation(String symbol) {
+        return Arrays.stream(values())
+                .filter(operator -> operator.symbol.equals(symbol))
+                .findAny()
+                .orElseThrow(() -> new InvalidParameterException("유효한 연산자가 아닙니다."));
+    }
+}

src/main/java/domain/Operator.java

@@ -0,0 +1,20 @@
+package domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class OperatorFactory implements CalculatorTokenFactory {
+
+    @Override
+    public List<Operator> extractList(String[] splits) {
+        return IntStream.range(0, splits.length)
+                .filter(i -> isOperatorPosition(i))
+                .mapToObj(i -> Operator.toOperation(splits[i]))
+                .collect(Collectors.toList());
+    }
+
+    private boolean isOperatorPosition(int index) {
+        return index % 2 != 0;
+    }
+}

src/main/java/domain/OperatorFactory.java

@@ -0,0 +1,18 @@
+package domain;
+
+public class StringCalculator {
+
+    public int calculate(Numbers numbers, Operations operations) {
+        int result = 0;
+        while (operations.hasNext()) {
+            Operator operator = operations.next();
+            Integer left = numbers.getNextNumber();
+            Integer right = numbers.getNextNumber();
+            result = operator.calculate(left, right);
+
+            numbers.add(result);
+        }
+        return result;
+    }
+}
+