로또 2단계 미션 제출합니다.

src/main/java/lotto/LottoApplication.java

@@ -3,6 +3,7 @@
 import lotto.domain.*;
 import lotto.view.LottoView;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class LottoApplication {
@@ -11,17 +12,33 @@ public static void main(String[] args) {
         LottoView lottoView = new LottoView();
 
         Money money = new Money(lottoView.inputMoney());
-        Lottos lottos = lottoSystem.buyLottos(money);
+        lottoSystem.setLottoCount(money);
+
+        int numberOfManualLotto = lottoView.inputNumberOfManualLotto();
+        lottoSystem.validateNumberOfManualLotto(numberOfManualLotto);
+
+        List<Lotto> allLottos = new ArrayList<>();
+
+        lottoView.printManualLottosDescription();
+        for (int i = 0; i < numberOfManualLotto; i++) {
+            List<Integer> manualNumbers = lottoView.inputManualLottos();
+            Lotto lotto = lottoSystem.convertNumbersToLotto(manualNumbers);
+            allLottos.add(lotto);
+        }
+
+        List<Lotto> autoLottos = lottoSystem.buyAutoLotto(numberOfManualLotto);
+        allLottos.addAll(autoLottos);
+
+        Lottos lottos = new Lottos(allLottos);
         lottoView.printLottos(lottos);
 
         List<Integer> answerAndBonusNumber = lottoView.inputAnswer();
         WinningNumber winningNumber = lottoSystem.convertToAnswer(answerAndBonusNumber);
-        lottoSystem.scoreLottos(lottos, winningNumber);
+        Result result = lottoSystem.scoreLottos(lottos, winningNumber);
 
-        Result result = lottoSystem.getResult();
         lottoView.printResult(result);
 
-        Profit profit = lottoSystem.calculateProfit();
+        Profit profit = lottoSystem.calculateProfit(result);
         lottoView.printProfit(profit);
     }
 }

src/main/java/lotto/LottoSystem.java

@@ -9,57 +9,57 @@
 public class LottoSystem {
     private static final Money LOTTO_PRICE = new Money(1000);
     private final RandomLottoGenerator numberGenerator;
-    private final Result result;
     private long lottoCount;
 
     public LottoSystem() {
         this.numberGenerator = new RandomLottoGenerator();
-        this.result = new Result();
         this.lottoCount = 0;
     }
 
     private long calculateLottoCount(Money money) {
         return money.divide(LOTTO_PRICE);
     }
 
-    public Lottos buyLottos(Money money) {
-        lottoCount = calculateLottoCount(money);
-        return generateLottos();
+    public List<Lotto> buyAutoLotto(int numberOfManualLotto) {
+        return generateAutoLottos(lottoCount - numberOfManualLotto);
+    }
+
+    public void validateNumberOfManualLotto(int numberOfManualLotto) {
+        if (numberOfManualLotto > lottoCount || numberOfManualLotto < 0) {
+            throw new IllegalArgumentException("유효하지 않은 수동 구매 개수입니다!");
+        }
     }
 
     public WinningNumber convertToAnswer(List<Integer> answerAndBonusNumber) {
-        List<Ball> answerBalls = answerAndBonusNumber.subList(0, 6)
-                .stream()
-                .map(Ball::new)
-                .collect(Collectors.toList());
+        Lotto lotto = convertNumbersToLotto(answerAndBonusNumber.subList(0, 6));
         Ball bonusBall = new Ball(answerAndBonusNumber.get(6));
 
-        Lotto lotto = new Lotto(answerBalls);
         return new WinningNumber(lotto, bonusBall);
     }
 
-    private Lottos generateLottos() {
-        return numberGenerator.generateLottos(lottoCount);
-    }
-
-    public void scoreLottos(Lottos lottos, WinningNumber winningNumber) {
-        for (int i = 0; i < lottoCount; i++) {
-            scoreLotto(lottos.get(i), winningNumber);
-        }
+    public Lotto convertNumbersToLotto(List<Integer> numbers) {
+        List<Ball> balls = numbers.stream()
+                .map(Ball::new)
+                .collect(Collectors.toList());
+        return new Lotto(balls);
     }
 
-    public Result getResult() {
-        return result;
+    private List<Lotto> generateAutoLottos(long count) {
+        return numberGenerator.generateAutoLottos(count);
     }
 
-    public void scoreLotto(Lotto lotto, WinningNumber winningNumber) {
-        result.scoreLotto(lotto, winningNumber);
+    public Result scoreLottos(Lottos lottos, WinningNumber winningNumber) {
+        return lottos.scoreLottos(winningNumber);
     }
 
-    public Profit calculateProfit() {
+    public Profit calculateProfit(Result result) {
         long reward = result.calculateReward();
         long seed = lottoCount * LOTTO_PRICE.getValue();
 
         return new Profit(reward, seed);
     }
+
+    public void setLottoCount(Money money) {
+        lottoCount = calculateLottoCount(money);
+    }
 }

src/main/java/lotto/domain/Lotto.java

@@ -27,7 +27,7 @@ private void validateBalls(List<Ball> balls) {
 
     private void validateNumberOfBalls(List<Ball> balls) {
         if (balls.size() != LOTTO_SIZE) {
-            throw new RuntimeException();
+            throw new IllegalStateException("로또 볼의 개수는 6개여야합니다!");
         }
     }
 

src/main/java/lotto/domain/Lottos.java

@@ -18,4 +18,12 @@ public int getSize() {
     public Lotto get(int ix) {
         return values.get(ix);
     }
+
+    public Result scoreLottos(WinningNumber winningNumber) {
+        Result result = new Result();
+        for (Lotto lotto : values) {
+            result.scoreLotto(lotto, winningNumber);
+        }
+        return result;
+    }
 }

src/main/java/lotto/domain/Money.java

@@ -13,7 +13,7 @@ public long getValue() {
         return this.value;
     }
 
-    public long divide (Money money) {
+    public long divide(Money money) {
         return this.value / money.getValue();
     }
 

src/main/java/lotto/domain/Result.java

@@ -16,8 +16,8 @@ public Result() {
     }
 
     public void scoreLotto(Lotto lotto, WinningNumber winningNumber) {
-        long answerCount = winningNumber.getWinningNumbers().getBalls().stream().filter(lotto::contain).count();
-        boolean isCorrectBonusBall = lotto.contain(winningNumber.getBonusNumber());
+        long answerCount = winningNumber.countCorrectNumbers(lotto);
+        boolean isCorrectBonusBall = winningNumber.hasBonusNumber(lotto);
 
         Ranking rank = getRank(answerCount, isCorrectBonusBall);
         addScore(rank);
@@ -60,7 +60,7 @@ private Ranking getRank(long answerCount, boolean isCorrectBonusBall) {
     public long calculateReward() {
         reward = 0L;
 
-        for (Entry<Ranking, Integer> entry: score.entrySet()) {
+        for (Entry<Ranking, Integer> entry : score.entrySet()) {
             Ranking rank = entry.getKey();
             int count = entry.getValue();
             reward += rank.getReward() * count;

src/main/java/lotto/domain/WinningNumber.java

@@ -10,15 +10,19 @@ public WinningNumber(Lotto winningNumbers, Ball bonusNumber) {
         this.bonusNumber = bonusNumber;
     }
 
-    private void validateBonusNumberNotInWinningNumbers(Lotto winningNumbers, Ball bonusNumber){
+    private void validateBonusNumberNotInWinningNumbers(Lotto winningNumbers, Ball bonusNumber) {
         boolean isContain = winningNumbers.contain(bonusNumber);
         if (isContain) {
             throw new IllegalStateException("중복된 숫자가 존재합니다!");
         }
     }
 
-    public Lotto getWinningNumbers() {
-        return this.winningNumbers;
+    public long countCorrectNumbers(Lotto lotto) {
+        return winningNumbers.getBalls().stream().filter(lotto::contain).count();
+    }
+
+    public boolean hasBonusNumber(Lotto lotto) {
+        return lotto.contain(bonusNumber);
     }
 
     public Ball getBonusNumber() {

src/main/java/lotto/generator/RandomLottoGenerator.java

@@ -2,51 +2,38 @@
 
 import lotto.domain.Ball;
 import lotto.domain.Lotto;
-import lotto.domain.Lottos;
-import lotto.domain.WinningNumber;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public class RandomLottoGenerator {
     private static final int MIN_NUMBER = 1;
     private static final int MAX_NUMBER = 45;
     private static final int LENGTH = 6;
-    private final List<Ball> ballPool;
+    private final List<Ball> ballPool = IntStream.rangeClosed(MIN_NUMBER, MAX_NUMBER)
+            .mapToObj(Ball::new)
+            .collect(Collectors.toList());
 
-    public RandomLottoGenerator() {
-        this.ballPool = new ArrayList<>();
-        IntStream.rangeClosed(MIN_NUMBER, MAX_NUMBER)
-                .forEach(number -> ballPool.add(new Ball(number)));
-    }
-
-    private List<Ball> generateNumbers(int length) {
+    private List<Ball> generateNumbers() {
         Collections.shuffle(ballPool);
-        return new ArrayList<>(ballPool.subList(0, length));
+        return new ArrayList<>(ballPool.subList(0, RandomLottoGenerator.LENGTH));
     }
 
-    public Lottos generateLottos(long lottoCount) {
+    public List<Lotto> generateAutoLottos(long lottoCount) {
         List<Lotto> lottos = new ArrayList<>();
         for (int i = 0; i < lottoCount; i++) {
             Lotto lotto = generateLotto();
             lottos.add(lotto);
         }
 
-        return new Lottos(lottos);
+        return lottos;
     }
 
     public Lotto generateLotto() {
-        List<Ball> balls = generateNumbers(LENGTH);
+        List<Ball> balls = generateNumbers();
         return new Lotto(balls);
     }
-
-    public WinningNumber generateWinningNumber() {
-        List<Ball> balls = generateNumbers(LENGTH + 1);
-        Lotto lotto = new Lotto(balls.subList(0, LENGTH));
-        Ball bonusBall = balls.get(LENGTH);
-
-        return new WinningNumber(lotto, bonusBall);
-    }
 }

src/main/java/lotto/view/LottoView.java

@@ -1,10 +1,12 @@
 package lotto.view;
 
+import lotto.domain.Lotto;
 import lotto.domain.Lottos;
 import lotto.domain.Profit;
-import lotto.enums.Ranking;
 import lotto.domain.Result;
+import lotto.enums.Ranking;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Scanner;
@@ -19,6 +21,12 @@ public long inputMoney() {
         return Long.parseLong(money);
     }
 
+    public int inputNumberOfManualLotto() {
+        System.out.println("수동으로 구매할 로또 수를 입력해 주세요.");
+        String count = scan.nextLine();
+        return Integer.parseInt(count);
+    }
+
     public void printLottos(Lottos lottos) {
         int size = lottos.getSize();
         System.out.printf("%d개를 구매했습니다.\n", size);
@@ -30,12 +38,16 @@ public void printLottos(Lottos lottos) {
         System.out.println();
     }
 
+    private List<Integer> stringToNumbers(String numbers) {
+        return Arrays.stream(numbers.split(", "))
+                .map(Integer::parseInt)
+                .collect(Collectors.toList());
+    }
+
     public List<Integer> inputAnswer() {
         System.out.println("지난 주 당첨 번호를 입력해 주세요.");
         String answerLotto = scan.nextLine();
-        List<Integer> answerAndBonusBall = Arrays.stream(answerLotto.split(", "))
-                .map(Integer::parseInt)
-                .collect(Collectors.toList());
+        List<Integer> answerAndBonusBall = stringToNumbers(answerLotto);
 
         System.out.println("보너스 볼을 입력해 주세요.");
         String bonusBallNumber = scan.nextLine();
@@ -61,6 +73,15 @@ public void printResult(Result result) {
         }
     }
 
+    public void printManualLottosDescription() {
+        System.out.println("수동으로 구매할 번호를 입력해 주세요.");
+    }
+
+    public List<Integer> inputManualLottos() {
+
+        String lottoNumbers = scan.nextLine();
+        return stringToNumbers(lottoNumbers);
+    }
 
     private String getGainOrLoss(Profit profit) {
         long integerPart = profit.getIntegerPart();

src/test/java/lotto/LottoSystemTest.java

@@ -19,16 +19,17 @@ public class LottoSystemTest {
     void 돈_2500원으로_로또_구매_테스트() {
         LottoSystem lottoSystem = new LottoSystem();
         Money money = new Money(2500);
-        Lottos lottos = lottoSystem.buyLottos(money);
+        lottoSystem.setLottoCount(money);
+
+        Lottos lottos = new Lottos(lottoSystem.buyAutoLotto(0));
 
         assertThat(lottos.getSize()).isEqualTo(2);
     }
 
     @Test
     void 수익률_계산_테스트() {
         LottoSystem lottoSystem = new LottoSystem();
-        Money money = new Money(2000);
-        lottoSystem.buyLottos(money);
+        lottoSystem.setLottoCount(new Money(2000));
 
         Lotto lotto1 = new Lotto(Arrays.asList(
                 new Ball(1),
@@ -46,6 +47,8 @@ public class LottoSystemTest {
                 new Ball(5),
                 new Ball(7)
         ));
+
+        Lottos lottos = new Lottos(Arrays.asList(lotto1, lotto2));
         WinningNumber winningNumber = new WinningNumber(
                 new Lotto(Arrays.asList(
                         new Ball(1),
@@ -56,10 +59,9 @@ public class LottoSystemTest {
                         new Ball(6)
                 )), new Ball(7));
 
-        lottoSystem.scoreLotto(lotto1, winningNumber);
-        lottoSystem.scoreLotto(lotto2, winningNumber);
+        Result result = lottoSystem.scoreLottos(lottos, winningNumber);
 
-        Profit profit = lottoSystem.calculateProfit();
+        Profit profit = lottoSystem.calculateProfit(result);
 
         assertThat(profit.toString()).isEqualTo(String.format("%d.%d", (2000000000+30000000) / 2000, 0));
     }