고생하셨습니다.

🎉 PR 머지 완료! 🎉

Author: kangminhyuk1111

README.md

@@ -0,0 +1,60 @@
+# 로또 - 클린코드
+
+## 1단계 - 로또 자동 구매
+
+### 기능 요구사항
+- 로또 구입 금액을 입력하면 구입 금액에 해당하는 로또를 발급해야 한다.
+  - 사용자에게 input으로 금액을 입력받아 파싱한다.
+
+
+- 로또 1장의 가격은 1000원이다.
+  - 로또 구매 금액을 입력 받는다. ex) 14,000원
+  - 1,000원에 1개의 로또를 살 수 있다. ex) 14,000원의 경우 14장의 로또가 지급된다.
+
+
+- 로또 자동 생성은 **Collections.shuffle()** 메소드 활용한다.
+  - **shuffle 메서드**를 사용해야하는 이유는, NumberGenerate 함수를 만들어서 사용시에, 중복되는 숫자가 존재 할 경우가 존재함.
+  - **shuffle 메서드**는 1~45 까지의 숫자를 먼저 random하게 섞고 이후 앞의 수 6개를 가져올 수 있기 때문에 중복 수가 존재하지 않도록 관리가 가능함.
+
+
+- Collections.sort() 메소드를 활용해 정렬 가능하다.
+  - Collections.shuffle()을 통해 숫자를 가져온 후, Collections.sort()로 정렬 후 반환.
+
+
+- ArrayList의 contains() 메소드를 활용하면 어떤 값이 존재하는지 유무를 판단할 수 있다.
+
+## 2단계 - 로또 당첨
+
+### 기능 요구 사항
+- 로또 당첨 번호를 받아 일치한 번호 수에 따라 당첨 결과를 보여준다.
+  - 로또 당첨 번호를 체크하는 LottoResultChecker 객체에서 로또 당첨 결과를 반환한다.
+  - InputParser를 통해 입력값을 체크한다.
+
+
+- 객체 책임
+  - LottoRank: 로또 당첨 등수를 나타내는 Enum으로 miss부터 six까지의 등급을 가짐
+  - LottoResult: 당첨 번호를 가지는 객체 `Lotto`를 상속하여 같은 로또이지만 당첨 결과값이라는 부분이 다름 비교하여 몇개가 맞는지 matchCount를 반환함
+  - LottoResultChecker: LottoResult를 기반으로 결과를 반환하도록 함.
+  - WinningResult: LottoResultChecker에서 반환한 결과로, 금액 및 통계 계산을 해줌.
+
+## 3단계 - 로또 2등 당첨
+- 2등을 위한 보너스볼을 추첨한다. 
+- 당첨 통계에 2등을 추가한다. 
+  - LottoRank 객체에 2등 당첨의 경우를 추가한다.
+
+
+- 2등 당첨 조건은 당첨 번호 5개 일치 + 보너스 볼 일치다.
+  - LottoResult에서 BonusBall이 일치하는지 검사해준다
+  - 보너스 볼 기능을 추가
+  - Rank 열거형에 2등 조건(5개 일치 + 보너스 볼 일치)을 추가
+  - 보너스 볼 일치 여부를 확인하는 로직을 구현.
+
+## 4단계 - 로또 수동 입력
+- 현재 로또 생성기는 자동 생성 기능만 제공한다. 
+- 사용자가 수동으로 추첨 번호를 입력할 수 있도록 해야 한다.
+- 입력한 금액, 자동 생성 숫자, 수동 생성 번호를 입력하도록 해야 한다.
+
+
+- 사용자가 직접 로또 번호를 입력할 수 있는 기능을 추가.
+- 수동 구매와 자동 구매를 혼합하여 사용할 수 있도록 구현.
+- 수동 로또 개수와 금액 검증 로직을 추가.

src/main/java/lotto/LottoMain.java

@@ -0,0 +1,12 @@
+package lotto;
+
+import lotto.controller.LottoController;
+
+public class LottoMain {
+
+  public static void main(String[] args) {
+    final LottoController lottoController = new LottoController();
+
+    lottoController.run();
+  }
+}

src/main/java/lotto/controller/LottoController.java

@@ -0,0 +1,50 @@
+package lotto.controller;
+
+import java.util.List;
+import lotto.domain.*;
+import lotto.ui.InputView;
+import lotto.ui.OutputView;
+import lotto.util.InputParser;
+
+public class LottoController {
+
+  private final LottoStore lottoStore = new LottoStore();
+
+  public void run() {
+    final Long inputPayment = InputView.inputPayment();
+
+    final Payment payment = InputParser.parsePayment(inputPayment);
+
+    Lottos userLottos = processLottoGeneration(payment);
+
+    LottoResultChecker resultChecker = processLottoResult();
+
+    displayResults(userLottos, resultChecker, payment);
+  }
+
+  private Lottos processLottoGeneration(Payment payment) {
+    final int manualLottoCount = InputView.inputManualLottoCount();
+    final List<String> manualLottoStrings = InputView.inputManualLottoStrings(manualLottoCount);
+
+    final Lottos manualLottos = InputParser.parseLottos(manualLottoStrings);
+
+    final Lottos userLottos = lottoStore.generateLottosWithManualLottos(manualLottos, payment);
+    OutputView.printLottos(userLottos);
+
+    return userLottos;
+  }
+
+  private LottoResultChecker processLottoResult() {
+    final LottoResult lottoResult = InputView.inputLottoResult();
+    final LottoNumber bonusBall = InputView.inputBonusBall();
+
+    return new LottoResultChecker(lottoResult, bonusBall);
+  }
+
+  private void displayResults(Lottos userLottos, LottoResultChecker checker, Payment payment) {
+    final WinningResult winningResult = checker.matchLottos(userLottos);
+
+    OutputView.printResults(winningResult);
+    OutputView.printPrize(winningResult, payment);
+  }
+}

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

@@ -0,0 +1,48 @@
+package lotto.domain;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Lotto {
+
+  private static final int LOTTO_SIZE = 6;
+
+  private final List<LottoNumber> numbers;
+
+  public Lotto(final List<LottoNumber> numbers) {
+    validateSize(numbers);
+    validateNoDuplicates(numbers);
+    this.numbers = new ArrayList<>(numbers);
+  }
+
+  public static Lotto of(final List<Integer> numbers) {
+    return new Lotto(numbers.stream().map(LottoNumber::of).toList());
+  }
+
+  public String toString() {
+    return numbers.toString();
+  }
+
+  public int size() {
+    return numbers.size();
+  }
+
+  public List<LottoNumber> numbers() {
+    return new ArrayList<>(numbers);
+  }
+
+  private static void validateSize(List<?> numbers) {
+    if (numbers.size() != LOTTO_SIZE) {
+      throw new IllegalArgumentException("로또 번호는 6개여야 합니다.");
+    }
+  }
+
+  private static void validateNoDuplicates(List<LottoNumber> items) {
+    Set<LottoNumber> uniqueItems = new HashSet<>(items);
+    if (uniqueItems.size() != items.size()) {
+      throw new IllegalArgumentException("로또 번호에 중복된 숫자가 있습니다.");
+    }
+  }
+}

src/main/java/lotto/domain/LottoNumber.java

@@ -0,0 +1,45 @@
+package lotto.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LottoNumber {
+
+  private static final int MIN_LOTTO_NUMBER = 1;
+  private static final int MAX_LOTTO_NUMBER = 45;
+
+  private static final Map<Integer, LottoNumber> CACHE = new HashMap<>();
+
+  static {
+    for (int i = MIN_LOTTO_NUMBER; i <= MAX_LOTTO_NUMBER; i++) {
+      CACHE.put(i, new LottoNumber(i));
+    }
+  }
+
+  private final int number;
+
+  private LottoNumber(final int number) {
+    this.number = number;
+  }
+
+  public static LottoNumber of(final int number) {
+    validateNumberRange(number);
+    return CACHE.get(number);
+  }
+
+  private static void validateNumberRange(final int number) {
+    if (number < MIN_LOTTO_NUMBER || number > MAX_LOTTO_NUMBER) {
+      throw new IllegalArgumentException("로또 번호는 " + MIN_LOTTO_NUMBER + "부터 " +
+          MAX_LOTTO_NUMBER + " 사이의 숫자여야 합니다.");
+    }
+  }
+
+  public int number() {
+    return number;
+  }
+
+  @Override
+  public String toString() {
+    return String.valueOf(number);
+  }
+}

src/main/java/lotto/domain/LottoResult.java

@@ -0,0 +1,32 @@
+package lotto.domain;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class LottoResult extends Lotto {
+
+  public LottoResult(final List<LottoNumber> numbers) {
+    super(numbers);
+  }
+
+  public static LottoResult of(final List<Integer> numbers) {
+    return new LottoResult(numbers.stream().map(LottoNumber::of).toList());
+  }
+
+  public int matchCount(final Lotto userLotto) {
+    List<LottoNumber> winningNumbers = this.numbers();
+    List<LottoNumber> userNumbers = userLotto.numbers();
+
+    Set<LottoNumber> winningNumbersSet = new HashSet<>(winningNumbers);
+
+    int count = 0;
+    for (LottoNumber number : userNumbers) {
+      if (winningNumbersSet.contains(number)) {
+        count++;
+      }
+    }
+
+    return count;
+  }
+}

src/main/java/lotto/domain/LottoResultChecker.java

@@ -0,0 +1,49 @@
+package lotto.domain;
+
+import java.util.EnumMap;
+import java.util.Map;
+
+public class LottoResultChecker {
+
+  private final LottoResult winningNumbers;
+  private final LottoNumber bonusBall;
+
+  public LottoResultChecker(final LottoResult winningNumbers, final LottoNumber bonusBall) {
+    validateNumber(winningNumbers, bonusBall);
+    this.winningNumbers = winningNumbers;
+    this.bonusBall = bonusBall;
+  }
+
+  public WinningResult matchLottos(Lottos userLottos) {
+    Map<Rank, Integer> rankCounts = new EnumMap<>(Rank.class);
+
+    for (Rank rank : Rank.values()) {
+      rankCounts.put(rank, 0);
+    }
+
+    for (Lotto lotto : userLottos) {
+      Rank rank = getRankByCount(lotto);
+      rankCounts.put(rank, rankCounts.get(rank) + 1);
+    }
+
+    return new WinningResult(rankCounts);
+  }
+
+  private Rank getRankByCount(final Lotto lotto) {
+    return Rank.valueOf(matchCount(lotto), hasBonusBall(lotto));
+  }
+
+  private boolean hasBonusBall(final Lotto lotto) {
+    return lotto.numbers().contains(bonusBall);
+  }
+
+  private int matchCount(Lotto userLotto) {
+    return winningNumbers.matchCount(userLotto);
+  }
+
+  private void validateNumber(final LottoResult winningNumbers, final LottoNumber bonusBall) {
+    if (winningNumbers.numbers().contains(bonusBall)) {
+      throw new RuntimeException("보너스 번호는 기존 번호와 중복될 수 없습니다.");
+    }
+  }
+}

src/main/java/lotto/domain/LottoStore.java

@@ -0,0 +1,47 @@
+package lotto.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class LottoStore {
+
+  private static final int LOTTO_LENGTH = 6;
+  private static final int MIN_LOTTO_NUMBER = 1;
+  private static final int MAX_LOTTO_NUMBER = 45;
+  private static final int LOTTO_PRICE = 1000;
+
+  private final List<LottoNumber> lottoNumberPool;
+
+  public LottoStore() {
+    this.lottoNumberPool = new ArrayList<>();
+    for (int i = MIN_LOTTO_NUMBER; i <= MAX_LOTTO_NUMBER; i++) {
+      lottoNumberPool.add(LottoNumber.of(i));
+    }
+  }
+
+  public Lottos generateLottosWithManualLottos(final Lottos manualLottos, final Payment payment) {
+    long autoLottoCount = payment.value() / LOTTO_PRICE;
+    List<Lotto> combinedLottos = new ArrayList<>(manualLottos.lottos());
+
+    for (int i = 0; i < autoLottoCount - manualLottos.size(); i++) {
+      combinedLottos.add(generateLotto());
+    }
+
+    return new Lottos(combinedLottos);
+  }
+
+  private Lotto generateLotto() {
+    List<LottoNumber> numberPool = new ArrayList<>(lottoNumberPool);
+
+    Collections.shuffle(numberPool);
+
+    List<LottoNumber> selectedNumbers = numberPool.subList(0, LOTTO_LENGTH);
+
+    List<LottoNumber> sortedNumbers = new ArrayList<>(selectedNumbers);
+    sortedNumbers.sort(Comparator.comparing(LottoNumber::number));
+
+    return new Lotto(sortedNumbers);
+  }
+}

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

@@ -0,0 +1,38 @@
+package lotto.domain;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public record Lottos(List<Lotto> lottos) implements Iterable<Lotto> {
+
+  public Lottos {
+    lottos = new ArrayList<>(lottos); // 불변성을 위한 방어적 복사
+  }
+
+  public void add(final Lotto lotto) {
+    lottos.add(lotto);
+  }
+
+  public void addAll(final Lottos manualLottos) {
+    lottos.addAll(manualLottos.lottos);
+  }
+
+  public int size() {
+    return lottos.size();
+  }
+
+  public static Lottos of(List<Lotto> lottos) {
+    return new Lottos(lottos);
+  }
+
+  @Override
+  public Iterator<Lotto> iterator() {
+    return lottos.iterator();
+  }
+
+  @Override
+  public List<Lotto> lottos() {
+    return lottos;
+  }
+}