[차재언] Step2(RacingGame) 피드백 반영.

src/main/java/calculator/Calculator.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import static calculator.ExceptionMessage.*;
@@ -16,19 +17,23 @@ public class Calculator {
     private static final String IS_NOT_MATH_EXPRESSION = "[^0-9+\\-*/]";
     private static final String MAKE_EMPTY = "";
     private static final int HAVE_NOT_APPENDED_NUMBER = 1;
+    private static final int FIRST_NUMBER_INDEX = 0;
+
+    Pattern notNumberPattern = Pattern.compile(NOT_NUMBER_PATTERN);
+    Pattern theEndIsNotNumberPattern = Pattern.compile(THE_END_IS_NOT_NUMBER);
+    Pattern isNotMathExpressionPattern = Pattern.compile(IS_NOT_MATH_EXPRESSION);
 
     public void printResult() {
-        Calculator calculator = new Calculator();
         outputStartMessage();
-        resultOutput(calculator.makeResult(makeSlicedMathExpression()));
+        resultOutput(makeResult(makeSlicedMathExpression()));
     }
 
     public double calculate(double firstNumber, String operator, double secondNumber) {
         return findValidatedSymbol(operator).operate(firstNumber, secondNumber);
     }
 
     private double makeResult(List<String> mathExpressions) {
-        double result = Double.parseDouble(mathExpressions.get(0));
+        double result = Double.parseDouble(mathExpressions.get(FIRST_NUMBER_INDEX));
         int mathExpressionSize = mathExpressions.size();
 
         for (int i = 1; i < mathExpressionSize; i += 2) {
@@ -54,13 +59,15 @@ private void validate(String mathExpression) {
     }
 
     private void isTheEndNotNumber(String mathExpression) {
-        if (Pattern.matches(THE_END_IS_NOT_NUMBER, mathExpression)) {
+        Matcher matcher = theEndIsNotNumberPattern.matcher(mathExpression);
+        if (matcher.matches()) {
             throw new IllegalArgumentException(THE_END_IS_NOT_NUMBER_MESSAGE);
         }
     }
 
     private void isNotMathExpression(String mathExpression) {
-        if (Pattern.matches(IS_NOT_MATH_EXPRESSION, mathExpression)) {
+        Matcher matcher = isNotMathExpressionPattern.matcher(mathExpression);
+        if (matcher.matches()) {
             throw new IllegalArgumentException(IS_NOT_MATH_EXPRESSION_MESSAGE);
         }
     }
@@ -95,10 +102,8 @@ private List<String> convertSplitExpressionArrayToList(String[] splitMathExpress
     }
 
     private boolean isNotNumberPattern(String mathSymbol) {
-        if (Pattern.matches(NOT_NUMBER_PATTERN, mathSymbol)) {
-            return true;
-        }
-        return false;
+        Matcher matcher = notNumberPattern.matcher(mathSymbol);
+        return matcher.matches();
     }
 
     private boolean haveIntegerExpression(String integerOfMathExpression) {

src/main/java/calculator/MathSymbol.java

@@ -22,9 +22,9 @@ public String getMathSymbol() {
 
     public static MathSymbol findValidatedSymbol(String operator) {
         return Arrays.stream(MathSymbol.values())
-                .filter(v -> v.getMathSymbol().equals(operator))
+                .filter(mathSymbol -> mathSymbol.getMathSymbol().equals(operator))
                 .findAny()
-                .orElseThrow(() -> new IllegalArgumentException(String.format("잘못된 연산자 입니다.")));
+                .orElseThrow(() -> new IllegalArgumentException("잘못된 연산자 입니다."));
     }
 
     public double operate(double firstNumber, double secondNumber) {

src/main/java/racing/RacingController.java

@@ -0,0 +1,29 @@
+package racing;
+
+import racing.domain.Car;
+import racing.domain.RacingGame;
+
+import java.util.List;
+
+import static racing.domain.RacingGame.SEPARATOR;
+import static racing.view.Input.makeCarNames;
+import static racing.view.Input.makeGameRepeatCount;
+import static racing.view.Output.*;
+import static racing.view.Output.printWinMessage;
+
+public class RacingController {
+    public static void main(String[] args) {
+        RacingGame racingGame = new RacingGame();
+
+        printStartMessage();
+        String carNames = makeCarNames();
+        printInputCountMessage();
+        int count = makeGameRepeatCount();
+        printResultMessage();
+        String[] carNameArray = carNames.split(SEPARATOR);
+        List<Car> carList = racingGame.makeCars(carNameArray);
+        carList = racingGame.repeatMoveCars(count, carList);
+        printNowDistance(carList);
+        printWinMessage(racingGame.findWinner(carList));
+    }
+}

src/main/java/racing/Car.java → src/main/java/racing/domain/Car.java

@@ -1,6 +1,8 @@
-package racing;
+package racing.domain;
 
 public class Car {
+    public static final int MOVE_CHANGE_CONDITION = 4;
+    public static final int VALIDATED_NAME_LENGTH = 5;
     private String name;
     private int moveCount;
 
@@ -10,15 +12,13 @@ public Car(String name) {
     }
 
     public void move(int randomNumber) {
-        if (randomNumber >= 4) {
+        if (randomNumber >= MOVE_CHANGE_CONDITION) {
             this.moveCount++;
         }
     }
 
-    private void validateLength(String name) {
-        if (name.length() > 5) {
-            throw new IllegalArgumentException("이름은 5자 이내로 입력하세요.");
-        }
+    public boolean isWinner(int winnerCount) {
+        return moveCount == winnerCount;
     }
 
     public String getName() {
@@ -29,4 +29,9 @@ public int getMoveCount() {
         return moveCount;
     }
 
+    private void validateLength(String name) {
+        if (name.length() > VALIDATED_NAME_LENGTH) {
+            throw new IllegalArgumentException("이름은 5자 이내로 입력하세요.");
+        }
+    }
 }

src/main/java/racing/domain/RacingGame.java

@@ -0,0 +1,54 @@
+package racing.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static racing.utils.RandomNumber.makeOneRandomNumber;
+
+public class RacingGame {
+    public static String SEPARATOR = ",";
+
+    public List<Car> makeCars(String[] carNameArray) {
+        List<Car> cars = new ArrayList<>();
+
+        for (String carName : carNameArray) {
+            cars.add(new Car(carName));
+        }
+        return cars;
+    }
+
+    public List<Car> repeatMoveCars(int count, List<Car> carList) {
+        for (int i = 0; i < count; i++) {
+            carList = moveCars(carList);
+        }
+        return carList;
+    }
+
+    public List<String> findWinner(List<Car> carList) {
+        List<String> winnerList = new ArrayList<>();
+        int winnerCondition = findWinnerCondition(carList);
+        for (Car car : carList) {
+            if (car.isWinner(winnerCondition)) {
+                winnerList.add(car.getName());
+            }
+        }
+        return winnerList;
+    }
+
+    private List<Car> moveCars(List<Car> carList) {
+        for (int i = 0; i < carList.size(); i++) {
+            carList.get(i).move(makeOneRandomNumber());
+        }
+        return carList;
+    }
+
+    private int findWinnerCondition(List<Car> carList) {
+        int winnerCondition = 0;
+        for (Car car : carList) {
+            if (car.getMoveCount() >= winnerCondition) {
+                winnerCondition = car.getMoveCount();
+            }
+        }
+        return winnerCondition;
+    }
+}

src/main/java/racing/view/Input.java

@@ -12,4 +12,4 @@ public static String makeCarNames() {
     public static int makeGameRepeatCount() {
         return scanner.nextInt();
     }
-}
+}

src/main/java/racing/view/Output.java

@@ -1,6 +1,6 @@
 package racing.view;
 
-import racing.Car;
+import racing.domain.Car;
 
 import java.util.List;
 
@@ -12,6 +12,7 @@ public class Output {
     private static final String LOAD = "-";
     private static final String WINNER_SEPARATOR = ", ";
     private static final String DISTANCE_SEPARATOR = " : ";
+    private static final int BUILDER_INIT = 0;
 
     public static void printStartMessage() {
         System.out.println(START_MESSAGE);
@@ -28,26 +29,34 @@ public static void printResultMessage() {
     public static void printWinMessage(List<String> winnerList) {
         System.out.print("\n" + WIN_MESSAGE);
 
-        int memberIndexOfRequiringSeparator = winnerList.size() -2;
+        int memberIndexOfRequiringSeparator = winnerList.size() - 2;
         int memberIndexOfNotRequiringSeparator = memberIndexOfRequiringSeparator + 1;
+        StringBuilder winMessageStringBuilder = new StringBuilder();
 
         for (int i = 0; i <= memberIndexOfRequiringSeparator; i++) {
-            System.out.print(winnerList.get(i) + WINNER_SEPARATOR);
+            winMessageStringBuilder.append(winnerList.get(i));
+            winMessageStringBuilder.append(WINNER_SEPARATOR);
+            System.out.print(winMessageStringBuilder);
+            winMessageStringBuilder.setLength(BUILDER_INIT);
         }
         System.out.println(winnerList.get(memberIndexOfNotRequiringSeparator));
     }
 
     public static void printNowDistance(List<Car> carList) {
         System.out.println();
+        StringBuilder distanceStringBuilder = new StringBuilder();
         for (int i = 0; i < carList.size(); i++) {
-            System.out.print(carList.get(i).getName() + DISTANCE_SEPARATOR);
+            distanceStringBuilder.append(carList.get(i).getName());
+            distanceStringBuilder.append(DISTANCE_SEPARATOR);
+            System.out.print(distanceStringBuilder);
             printLoadConstant(carList.get(i).getMoveCount());
             System.out.println();
+            distanceStringBuilder.setLength(BUILDER_INIT);
         }
     }
 
-    private static void printLoadConstant(int gameRepeatCount) {
-        for (int j = 0; j < gameRepeatCount; j++) {
+    private static void printLoadConstant(int moveCount) {
+        for (int j = 0; j < moveCount; j++) {
             System.out.print(LOAD);
         }
     }