🚀 4단계 - 로또(수동)

README.md

@@ -48,4 +48,7 @@
 - [X] 보너스볼 기능 추가
   - [X] 보너스볼 사용자 입력 구현
   - [X] 보너스볼을 포함한 로또 생성
-  - [X] 당첨 통계에 2등 추가
+  - [X] 당첨 통계에 2등 추가
+- [X] 수동 로또 구매 구현
+  - [X] 구입개수보다 큰 경우 오류
+- [ ] 수동 로또 번호 입력 구현

src/main/java/lotto/LottoController.java

@@ -6,15 +6,17 @@
 import lotto.view.InputView;
 import lotto.view.ResultView;
 
+import java.util.List;
 import java.util.Map;
 
 public class LottoController {
 
     public static void main(String[] args) {
         int purchasePrice = InputView.askPurchasePrice();
+        List<Lotto> manualLottoList = InputView.askManualLottoCountAndNumber();
 
         LottoGenerator lottoRandomGenerator = new LottoRandomGenerator();
-        LottoBundle lottoBundle = new LottoBundle(lottoRandomGenerator, purchasePrice);
+        LottoBundle lottoBundle = new LottoBundle(lottoRandomGenerator, purchasePrice, manualLottoList);
         ResultView.printPurchaseInfo(lottoBundle);
 
         Lotto winningLotto = InputView.askLottoWinningNumbers();

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

@@ -1,7 +1,7 @@
 package lotto.domain;
 
 import java.util.Arrays;
-import java.util.List;
+import java.util.Collections;
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
@@ -12,19 +12,19 @@ public class Lotto {
 
     private final Set<LottoNumber> numbers;
 
-    public Lotto(List<Integer> numbers) {
+    public Lotto(Set<Integer> numbers) {
         this.numbers = new TreeSet<>(parseLottoNumber(numbers));
         validate();
     }
 
     public Lotto(Integer... numbers) {
-        this(Arrays.asList(numbers));
+        this(Set.copyOf(Arrays.asList(numbers)));
     }
 
-    private List<LottoNumber> parseLottoNumber(List<Integer> numbers) {
+    private Set<LottoNumber> parseLottoNumber(Set<Integer> numbers) {
         return numbers.stream()
                 .map(value -> new LottoNumber(value))
-                .collect(Collectors.toList());
+                .collect(Collectors.toSet());
     }
 
     private void validate() {
@@ -33,18 +33,18 @@ private void validate() {
         }
     }
 
-    public List<LottoNumber> numbers() {
-        return this.numbers.stream().collect(Collectors.toList());
+    public Set<LottoNumber> numbers() {
+        return Collections.unmodifiableSet(this.numbers);
     }
 
     public boolean hasNumber(LottoNumber lottoNumber) {
-        return this.numbers().contains(lottoNumber);
+        return this.numbers.contains(lottoNumber);
     }
 
     public int matchCount(Lotto winningLotto) {
         return (int) winningLotto.numbers()
                 .stream()
-                .filter(value -> this.hasNumber(value))
+                .filter(this::hasNumber)
                 .count();
     }
 

src/main/java/lotto/domain/LottoBundle.java

@@ -2,51 +2,82 @@
 
 import lotto.strategy.LottoGenerator;
 
-import java.util.Arrays;
-import java.util.EnumMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public class LottoBundle {
 
     private static final int LOTTO_PRICE = 1000;
 
-    private final List<Lotto> lottoList;
+    private final List<Lotto> manualLottoList;
+    private final List<Lotto> automaticLottoList;
 
-    public LottoBundle(List<Lotto> lottoList) {
-        this.lottoList = lottoList;
+    public LottoBundle(List<Lotto> automaticLottoList, List<Lotto> manualLottoList) {
+        this.manualLottoList = manualLottoList;
+        this.automaticLottoList = automaticLottoList;
+    }
+
+    public LottoBundle(List<Lotto> automaticLottoList) {
+        this(automaticLottoList, new ArrayList<>());
+    }
+
+    public LottoBundle(LottoGenerator lottoGenerator, int lottoPurchasedPrice, List<Lotto> manualLottoList) {
+        this(
+                IntStream.range(0, getAutomaticCount(lottoPurchasedPrice, manualLottoList.size()))
+                        .mapToObj(i -> lottoGenerator.generate())
+                        .collect(Collectors.toList()),
+                manualLottoList
+        );
     }
 
     public LottoBundle(LottoGenerator lottoGenerator, int lottoPurchasedPrice) {
-        this(IntStream.range(0, lottoPurchasedPrice / LOTTO_PRICE)
-                .mapToObj(i -> lottoGenerator.generate())
-                .collect(Collectors.toList()));
+        this(lottoGenerator, lottoPurchasedPrice, new ArrayList<>());
+    }
+
+    private static int getAutomaticCount(int lottoPurchasedPrice, int manualCount) {
+        int totalCount = lottoPurchasedPrice / LOTTO_PRICE;
+        if (totalCount < manualCount) {
+            throw new IllegalArgumentException(
+                    String.format("구매한 로또 개수는 %d개입니다. %d개 이하로 입력해주세요.", totalCount, totalCount)
+            );
+        }
+
+        return (lottoPurchasedPrice / LOTTO_PRICE) - manualCount;
     }
 
     public Map<LottoResult, Integer> checkWinningResult(WinningLotto winningLotto) {
         Map<LottoResult, Integer> lottoResults = Arrays.stream(LottoResult.values())
                 .collect(Collectors.toMap(key -> key, value -> 0, (x, y) -> y, () -> new EnumMap<>(LottoResult.class)));
 
-        for (Lotto lotto : lottoList) {
+        for (Lotto lotto : lottoList()) {
             LottoResult lottoResult = winningLotto.getLottoResult(lotto);
             lottoResults.put(lottoResult, lottoResults.get(lottoResult) + 1);
         }
 
         return lottoResults;
     }
 
-    public int lottoCount() {
-        return lottoList.size();
+    public List<Lotto> lottoList() {
+        List<Lotto> totalLottoList = new ArrayList<>();
+        totalLottoList.addAll(manualLottoList);
+        totalLottoList.addAll(automaticLottoList);
+        return totalLottoList;
     }
 
-    public List<Lotto> lottoList() {
-        return lottoList;
+    public int totalLottoCount() {
+        return manualLottoList.size() + automaticLottoList.size();
     }
 
     public int purchasedPrice() {
-        return lottoCount() * LOTTO_PRICE;
+        return totalLottoCount() * LOTTO_PRICE;
     }
 
+    public int manualCount() {
+        return this.manualLottoList.size();
+    }
+
+    public int automaticCount() {
+        return automaticLottoList.size();
+    }
 }

src/main/java/lotto/domain/WinningLotto.java

@@ -13,10 +13,10 @@ public WinningLotto(Lotto winningLotto, LottoNumber bonus) {
 
     private void validate() {
         this.winningLotto.numbers().stream()
-                .filter(winningLottoNumber -> winningLottoNumber.equals(this.bonus))
+                .filter(winningLottoNumber -> winningLotto.hasNumber(this.bonus))
                 .findAny()
                 .ifPresent(a -> {
-                    throw new IllegalArgumentException();
+                    throw new IllegalArgumentException("보너스번호가 당첨번호에 이미 포함된 번호입니다.");
                 });
     }
 

src/main/java/lotto/strategy/LottoRandomGenerator.java

@@ -6,6 +6,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
 public class LottoRandomGenerator implements LottoGenerator {
 
@@ -17,7 +18,7 @@ public Lotto generate() {
         }
         Collections.shuffle(numbers);
 
-        return new Lotto(numbers.subList(0, Lotto.LOTTO_NUMBER_COUNT));
+        return new Lotto(Set.copyOf(numbers.subList(0, Lotto.LOTTO_NUMBER_COUNT)));
     }
 
 }

src/main/java/lotto/view/InputView.java

@@ -3,9 +3,7 @@
 import lotto.domain.Lotto;
 import lotto.domain.LottoNumber;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.Scanner;
+import java.util.*;
 import java.util.stream.Collectors;
 
 public class InputView {
@@ -19,6 +17,10 @@ public static int askPurchasePrice() {
 
     public static Lotto askLottoWinningNumbers() {
         System.out.println("지난 주 당첨 번호를 입력해 주세요.");
+        return getLotto();
+    }
+
+    private static Lotto getLotto() {
         return new Lotto(parseInt(asList(split(scanner.nextLine()))));
     }
 
@@ -36,15 +38,28 @@ private static List<String> asList(String[] winningNumbers) {
         return Arrays.asList(winningNumbers);
     }
 
-    private static List<Integer> parseInt(List<String> winningNumbers) {
+    private static Set<Integer> parseInt(List<String> winningNumbers) {
         return winningNumbers.stream()
                 .mapToInt(Integer::parseInt)
                 .boxed()
-                .collect(Collectors.toList());
+                .collect(Collectors.toSet());
     }
 
     public static LottoNumber askBonusNumber() {
         System.out.println("보너스 볼을 입력해 주세요.");
         return new LottoNumber(scanInt());
     }
+
+    public static List<Lotto> askManualLottoCountAndNumber() {
+        System.out.println("수동으로 구매할 로또 수를 입력해 주세요.");
+        int manualLottoCount = scanInt();
+
+        System.out.println("수동으로 구매할 번호를 입력해 주세요.");
+        List<Lotto> lottoList = new ArrayList<>();
+        for (int index = 0; index < manualLottoCount; index++) {
+            lottoList.add(getLotto());
+        }
+
+        return lottoList;
+    }
 }

src/main/java/lotto/view/ResultView.java

@@ -12,7 +12,7 @@
 public class ResultView {
 
     public static void printPurchaseInfo(LottoBundle lottoBundle) {
-        System.out.printf("%d개를 구매했습니다.", lottoBundle.lottoCount());
+        System.out.printf("수동으로 %d장, 자동으로 %d개를 구매했습니다.\n", lottoBundle.manualCount(), lottoBundle.automaticCount());
         printLottoNumbers(lottoBundle.lottoList());
     }
 

src/test/java/lotto/domain/LottoBundleTest.java

@@ -6,10 +6,12 @@
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 public class LottoBundleTest {
 
@@ -38,8 +40,53 @@ public static List<Arguments> LottoResultProvider() {
     @Test
     void 로또_여러개_구매() {
         LottoBundle lottoBundle = new LottoBundle(new LottoRandomGenerator(), 5000);
-        assertThat(lottoBundle.lottoCount()).isEqualTo(5);
+        assertThat(lottoBundle.totalLottoCount()).isEqualTo(5);
         assertThat(lottoBundle.purchasedPrice()).isEqualTo(5000);
     }
 
+    @Test
+    void 로또_수동_구매() {
+        List<Lotto> manualLottoList = Arrays.asList(
+                new Lotto(1, 2, 3, 4, 5, 6),
+                new Lotto(7, 8, 9, 10, 11, 12),
+                new Lotto(13, 14, 15, 16, 17, 18)
+        );
+        LottoBundle lottoBundle = new LottoBundle(new LottoRandomGenerator(), 5000, manualLottoList);
+        assertThat(lottoBundle.manualCount()).isEqualTo(3);
+        assertThat(lottoBundle.automaticCount()).isEqualTo(2);
+    }
+
+    @Test
+    void 로또구매_개수보다_수동개수를_더_많이_입력한_경우_오류() {
+        List<Lotto> manualLottoList = Arrays.asList(
+                new Lotto(1, 2, 3, 4, 5, 6),
+                new Lotto(7, 8, 9, 10, 11, 12),
+                new Lotto(13, 14, 15, 16, 17, 18),
+                new Lotto(19, 20, 21, 22, 23, 24),
+                new Lotto(25, 26, 27, 28, 29, 30),
+                new Lotto(31, 32, 33, 34, 35, 36)
+        );
+
+        assertThatThrownBy(() -> {
+            new LottoBundle(new LottoRandomGenerator(), 5000, manualLottoList);
+        }).isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("구매한 로또 개수는 5개입니다. 5개 이하로 입력해주세요.");
+    }
+
+    @Test
+    void 수동로또_정보확인() {
+        List<Lotto> manualLottoList = Arrays.asList(
+                new Lotto(1, 2, 3, 4, 5, 6),
+                new Lotto(7, 8, 9, 10, 11, 12),
+                new Lotto(13, 14, 15, 16, 17, 18)
+        );
+
+        LottoBundle lottoBundle = new LottoBundle(new LottoRandomGenerator(), 5000, manualLottoList);
+
+        List<Lotto> lottoList = lottoBundle.lottoList();
+        assertThat(lottoList.get(0)).usingRecursiveComparison().isEqualTo(manualLottoList.get(0));
+        assertThat(lottoList.get(1)).usingRecursiveComparison().isEqualTo(manualLottoList.get(1));
+        assertThat(lottoList.get(2)).usingRecursiveComparison().isEqualTo(manualLottoList.get(2));
+    }
+
 }

src/test/java/lotto/domain/LottoTest.java

@@ -8,7 +8,6 @@
 import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
 
-import java.util.Arrays;
 import java.util.List;
 import java.util.Set;
 
@@ -35,21 +34,21 @@ class LottoTest {
     @Test
     void 수동생성테스트_로또숫자_중복일_경우_IllegalArgumentException_오류발생() {
         assertThatThrownBy(() -> {
-            new Lotto(Arrays.asList(1, 2, 3, 4, 5, 5));
+            new Lotto(1, 2, 3, 4, 5, 5);
         }).isInstanceOf(IllegalArgumentException.class);
     }
 
     @ParameterizedTest
     @ValueSource(ints = {0, 46})
     void 수동생성테스트_로또숫자범위_벗어날_경우_IllegalArgumentException_오류발생(int invalidNumber) {
         assertThatThrownBy(() -> {
-            new Lotto(Arrays.asList(1, 2, 3, 4, 5, invalidNumber));
+            new Lotto(1, 2, 3, 4, 5, invalidNumber);
         }).isInstanceOf(IllegalArgumentException.class);
     }
 
     @ParameterizedTest
     @MethodSource("LottoMatchParameterProvider")
-    void 로또_일치_확인(List<Integer> lottoList, LottoResult expected) {
+    void 로또_일치_확인(Integer[] lottoList, LottoResult expected) {
         WinningLotto winningLotto = new WinningLotto(new Lotto(1, 2, 3, 4, 5, 6), new LottoNumber(7));
         Lotto lotto = new Lotto(lottoList);
 
@@ -60,12 +59,12 @@ class LottoTest {
 
     private static List<Arguments> LottoMatchParameterProvider() {
         return List.of(
-                Arguments.of(Arrays.asList(1, 3, 5, 7, 9, 11), LottoResult.THREE),
-                Arguments.of(Arrays.asList(1, 2, 3, 4, 9, 11), LottoResult.FOUR),
-                Arguments.of(Arrays.asList(1, 2, 3, 4, 5, 11), LottoResult.FIVE),
-                Arguments.of(Arrays.asList(1, 2, 3, 4, 5, 7), LottoResult.BONUS),
-                Arguments.of(Arrays.asList(1, 2, 3, 4, 5, 6), LottoResult.SIX),
-                Arguments.of(Arrays.asList(6, 7, 8, 9, 10, 11), LottoResult.FAIL)
+                Arguments.of(new Integer[]{1, 3, 5, 7, 9, 11}, LottoResult.THREE),
+                Arguments.of(new Integer[]{1, 2, 3, 4, 9, 11}, LottoResult.FOUR),
+                Arguments.of(new Integer[]{1, 2, 3, 4, 5, 11}, LottoResult.FIVE),
+                Arguments.of(new Integer[]{1, 2, 3, 4, 5, 7}, LottoResult.BONUS),
+                Arguments.of(new Integer[]{1, 2, 3, 4, 5, 6}, LottoResult.SIX),
+                Arguments.of(new Integer[]{6, 7, 8, 9, 10, 11}, LottoResult.FAIL)
         );
     }