[로또] 이준섭 미션 제출합니다.

docs/README.md

@@ -0,0 +1,30 @@
+Application과 동일 선상에 RunLotto 클래스 생성
+
+LottoManager에 필요한 기능들을 패키지로 묶어보자
+
+- 도메인 모델 패키지 (domain)
+    - 사용자로부터 입력받은 구입금액을 저장하는 클래스 PurchaseAmount
+    - 난수 생성된 로또 번호가 있는 클래스 Lotto
+    - 사용자로부터 로또 번호 6개와 보너스 번호 1개를 입력받아 저장하는 클래스 UserInputNumbers
+    - 상금과 당첨 수를 저장하는 열거형 enum WinningCheck
+- 비즈니스 로직을 수행하는 서비스 패키지 (service)
+    - 당첨 결과를 계산하는 클래스 LottoResultCalculator
+    - 수익률을 계산하는 클래스 LottoProfitRateCalculator
+    - 구입금액만큼 로또를 발행하는 클래스 LottoGenerator
+- 각종 메서드가 있는 패키지 (util)
+    - 사용자로부터 값들을 입력받는 클래스 InputManager
+    - 결과들을 출력하는 클래스 OutputManager
+
+동작 구조
+
+1. receivePurchaseAmount()로 구입금액을 입력받아 PurchaseAmount에 객체로 저장(유효성 검사)
+2. 생성된 PurchaseAmount를 받아 generateLottos(PurchaseAmount purchaseAmount)
+   입력받은 양 만큼 Lotto 객체로 로또를 발행(유효성 검사) -> 리턴 값은 List<Lotto>로 generatedLottos를 리턴
+3. generatedLottos를 매개변수로 받아 printGeneratedLottoNumbers(List<Lotto> lottos) 생성된 로또들을 출력
+4. calculateWinningResult(List<Lotto> lottos, UserInputNumbers receivedLotto)
+   Map<WinningCheck, Integer>을 이용해서 result를 생성 WinningCheck에 열거형으로 상금과 당첨 수를 저장
+   Lotto클래스에서 각 로또 당 matchCount와 bonusMatch를 가져온다 -> WinningCheck.getPrize(matchCount, bonusMatch)
+   -> 각 로또 당 상금과 수를 result에 저장 후 리턴
+5. calculateProfitRate(PurchaseAmount purchaseAmount, Map<WinningCheck, Integer> result)
+   구입금액과 결과를 비교하여 수익률을 계산(소수 둘째에서 반올림) -> 리턴 값은 double profitRate
+6. printResults(Map<WinningCheck, Integer> result, double profitRate) 최종 결과 출력

src/main/java/lotto/Application.java

@@ -1,7 +1,9 @@
 package lotto;
 
 public class Application {
-    public static void main(String[] args) {
-        // TODO: 프로그램 구현
-    }
+
+  public static void main(String[] args) {
+    LottoManager lottoManager = new LottoManager();
+    lottoManager.runLotto();
+  }
 }

src/main/java/lotto/LottoManager.java

@@ -0,0 +1,38 @@
+package lotto;
+
+import java.util.List;
+import java.util.Map;
+import lotto.domain.Lotto;
+import lotto.domain.PurchaseAmount;
+import lotto.domain.UserInputNumbers;
+import lotto.service.LottoProfitRateCalculator;
+import lotto.service.LottoResultCalculator;
+import lotto.util.InputManager;
+import lotto.service.LottoGenerator;
+import lotto.util.OutputManager;
+import lotto.domain.WinningCheck;
+
+public class LottoManager {
+
+  private final InputManager inputManager = new InputManager();
+  private final LottoGenerator lottoGenerator = new LottoGenerator();
+  private final LottoResultCalculator lottoResultCalculator = new LottoResultCalculator();
+  private final LottoProfitRateCalculator lottoProfitRateCalculator = new LottoProfitRateCalculator();
+  private final OutputManager outputManager = new OutputManager();
+
+  public void runLotto() {
+    PurchaseAmount purchaseAmount = inputManager.receivePurchaseAmount();
+
+    List<Lotto> generatedLottos = lottoGenerator.generateLottos(purchaseAmount);
+    outputManager.printGeneratedLottoNumbers(generatedLottos);
+
+    UserInputNumbers userInputNumbers = inputManager.receiveLottoNumber();
+
+    Map<WinningCheck, Integer> result = lottoResultCalculator
+        .calculateWinningResult(generatedLottos, userInputNumbers);
+    double profitRate = lottoProfitRateCalculator
+        .calculateProfitRate(purchaseAmount, result);
+
+    outputManager.printResults(result, profitRate);
+  }
+}

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

@@ -0,0 +1,50 @@
+package lotto.domain;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import lotto.util.ErrorMessage;
+
+public class Lotto {
+
+  public static final int MIN_LOTTO_NUMBER = 1;
+  public static final int MAX_LOTTO_NUMBER = 45;
+  public static final int SIZE_OF_LOTTO = 6;
+  private final List<Integer> lottoNumbers;
+
+  public Lotto(List<Integer> lottoNumbers) {
+    validateLottoNumbers(lottoNumbers);
+    this.lottoNumbers = lottoNumbers;
+  }
+
+  public int getMatchCount(UserInputNumbers receivedLotto) {
+    return (int) lottoNumbers.stream()
+        .filter(number -> receivedLotto.getReceivedLottoNumbers().contains(number))
+        .count();
+  }
+
+  public boolean isBonusMatch(UserInputNumbers receivedLotto) {
+    return lottoNumbers.contains(receivedLotto.getBonusNumber());
+  }
+
+  private void validateLottoNumbers(List<Integer> lottoNumbers) {
+    if (lottoNumbers.size() != SIZE_OF_LOTTO) {
+      throw new IllegalArgumentException(ErrorMessage.NOT_SIX_NUMBERS.getMessage());
+    }
+
+    for (int number : lottoNumbers) {
+      if (number < MIN_LOTTO_NUMBER || number > MAX_LOTTO_NUMBER) {
+        throw new IllegalArgumentException(ErrorMessage.NOT_IN_RANGE.getMessage());
+      }
+    }
+
+    Set<Integer> uniqueNumbers = new HashSet<>(lottoNumbers);
+    if (uniqueNumbers.size() < lottoNumbers.size()) {
+      throw new IllegalArgumentException(ErrorMessage.MUST_NOT_DUPLICATE.getMessage());
+    }
+  }
+
+  public List<Integer> getLottoNumbers() {
+    return lottoNumbers;
+  }
+}

src/main/java/lotto/domain/PurchaseAmount.java

@@ -0,0 +1,24 @@
+package lotto.domain;
+
+import lotto.util.ErrorMessage;
+
+public class PurchaseAmount {
+
+  public static final int LOTTO_PRICE = 1000;
+  private final int purchaseAmount;
+
+  public PurchaseAmount(int inputAmount) {
+    validatePurchaseAmount(inputAmount);
+    this.purchaseAmount = inputAmount;
+  }
+
+  private void validatePurchaseAmount(int inputAmount) {
+    if (inputAmount % LOTTO_PRICE != 0) {
+      throw new IllegalArgumentException(ErrorMessage.NOT_A_UNIT_OF_1000.getMessage());
+    }
+  }
+
+  public int getPurchaseAmount() {
+    return purchaseAmount;
+  }
+}

src/main/java/lotto/domain/UserInputNumbers.java

@@ -0,0 +1,58 @@
+package lotto.domain;
+
+import static lotto.domain.Lotto.MIN_LOTTO_NUMBER;
+import static lotto.domain.Lotto.MAX_LOTTO_NUMBER;
+import static lotto.domain.Lotto.SIZE_OF_LOTTO;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import lotto.util.ErrorMessage;
+
+public class UserInputNumbers {
+
+  private final List<Integer> receivedLottoNumbers;
+  private final int bonusNumber;
+
+  public UserInputNumbers(List<Integer> receivedLottoNumbers, int bonusNumber) {
+    validateLottoNumbers(receivedLottoNumbers);
+    this.receivedLottoNumbers = receivedLottoNumbers;
+    validateBonusNumbers(bonusNumber);
+    this.bonusNumber = bonusNumber;
+  }
+
+  private void validateLottoNumbers(List<Integer> receivedLottoNumbers) {
+    if (receivedLottoNumbers.size() != SIZE_OF_LOTTO) {
+      throw new IllegalArgumentException(ErrorMessage.NOT_SIX_NUMBERS.getMessage());
+    }
+
+    for (int number : receivedLottoNumbers) {
+      if (number < MIN_LOTTO_NUMBER || number > MAX_LOTTO_NUMBER) {
+        throw new IllegalArgumentException(ErrorMessage.NOT_IN_RANGE.getMessage());
+      }
+    }
+
+    Set<Integer> uniqueNumbers = new HashSet<>(receivedLottoNumbers);
+    if (uniqueNumbers.size() < receivedLottoNumbers.size()) {
+      throw new IllegalArgumentException(ErrorMessage.MUST_NOT_DUPLICATE.getMessage());
+    }
+  }
+
+  private void validateBonusNumbers(int bonusNumber) {
+    if (bonusNumber < MIN_LOTTO_NUMBER || bonusNumber > MAX_LOTTO_NUMBER) {
+      throw new IllegalArgumentException(ErrorMessage.NOT_IN_RANGE.getMessage());
+    }
+
+    if (new HashSet<>(receivedLottoNumbers).contains(bonusNumber)) {
+      throw new IllegalArgumentException(ErrorMessage.MUST_NOT_DUPLICATE.getMessage());
+    }
+  }
+
+  public List<Integer> getReceivedLottoNumbers() { // 결과 계산에 호출됨
+    return receivedLottoNumbers;
+  }
+
+  public int getBonusNumber() {
+    return bonusNumber;
+  }
+}

src/main/java/lotto/domain/WinningCheck.java

@@ -0,0 +1,54 @@
+package lotto.domain;
+
+public enum WinningCheck {
+  LOSE(0, 0),
+  FIFTH_PRIZE(5_000, 3),
+  FOURTH_PRIZE(50_000, 4),
+  THIRD_PRIZE(1_500_000, 5, false),
+  SECOND_PRIZE(30_000_000, 5, true),
+  FIRST_PRIZE(2_000_000_000, 6);
+
+  private final int prizeAmount;
+  private final int matchingCount;
+  private final boolean hasBonus;
+
+  WinningCheck(int prizeAmount, int matchingCount) {
+    this.prizeAmount = prizeAmount;
+    this.matchingCount = matchingCount;
+    this.hasBonus = false;
+  }
+
+  WinningCheck(int prizeAmount, int matchingCount, boolean hasBonus) {
+    this.prizeAmount = prizeAmount;
+    this.matchingCount = matchingCount;
+    this.hasBonus = hasBonus;
+  }
+
+  public static WinningCheck getPrize(int matchCount, boolean bonusMatch) {
+    if (matchCount == 6) {
+      return FIRST_PRIZE;
+    }
+    if (matchCount == 5) {
+      return bonusMatch ? SECOND_PRIZE : THIRD_PRIZE;
+    }
+    if (matchCount == 4) {
+      return FOURTH_PRIZE;
+    }
+    if (matchCount == 3) {
+      return FIFTH_PRIZE;
+    }
+    return LOSE;
+  }
+
+  public int getPrizeAmount() {
+    return prizeAmount;
+  }
+
+  public int getMatchingCount() {
+    return matchingCount;
+  }
+
+  public boolean hasBonus() {
+    return hasBonus;
+  }
+}

src/main/java/lotto/service/LottoGenerator.java

@@ -0,0 +1,38 @@
+package lotto.service;
+
+import static lotto.domain.Lotto.MAX_LOTTO_NUMBER;
+import static lotto.domain.Lotto.MIN_LOTTO_NUMBER;
+import static lotto.domain.Lotto.SIZE_OF_LOTTO;
+import static lotto.domain.PurchaseAmount.LOTTO_PRICE;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import java.util.ArrayList;
+import java.util.List;
+import lotto.domain.Lotto;
+import lotto.domain.PurchaseAmount;
+
+public class LottoGenerator {
+
+  public static List<Lotto> generateLottos(PurchaseAmount purchaseAmount) {
+    int numberOfLotto = purchaseAmount.getPurchaseAmount() / LOTTO_PRICE;
+    System.out.println("\n" + numberOfLotto + "개를 구매했습니다.");
+
+    List<Lotto> generatedLottos = new ArrayList<>();
+
+    for (int i = 0; i < numberOfLotto; i++) {
+      List<Integer> lottoNumbers =
+          Randoms.pickUniqueNumbersInRange(MIN_LOTTO_NUMBER, MAX_LOTTO_NUMBER, SIZE_OF_LOTTO);
+
+      try {
+        Lotto lotto = new Lotto(lottoNumbers);
+        generatedLottos.add(lotto);
+      } catch (IllegalArgumentException e) {
+        System.out.println(e.getMessage());
+        i--;
+      }
+    }
+
+    return generatedLottos;
+  }
+
+}

src/main/java/lotto/service/LottoProfitRateCalculator.java

@@ -0,0 +1,22 @@
+package lotto.service;
+
+import java.text.DecimalFormat;
+import java.util.Map;
+import lotto.domain.PurchaseAmount;
+import lotto.domain.WinningCheck;
+
+public class LottoProfitRateCalculator {
+
+  private static final int PERCENTAGE_FACTOR = 100;
+
+  public double calculateProfitRate(PurchaseAmount purchaseAmount,
+      Map<WinningCheck, Integer> result) {
+    double totalPrize = result.entrySet().stream()
+        .mapToInt(entry -> entry.getKey().getPrizeAmount() * entry.getValue())
+        .sum();
+
+    double profitRate = (totalPrize / purchaseAmount.getPurchaseAmount()) * PERCENTAGE_FACTOR;
+    DecimalFormat df = new DecimalFormat("#.##");
+    return Double.parseDouble(df.format(profitRate));
+  }
+}

src/main/java/lotto/service/LottoResultCalculator.java

@@ -0,0 +1,24 @@
+package lotto.service;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import lotto.domain.Lotto;
+import lotto.domain.UserInputNumbers;
+import lotto.domain.WinningCheck;
+
+public class LottoResultCalculator {
+
+  public Map<WinningCheck, Integer> calculateWinningResult(List<Lotto> lottos,
+      UserInputNumbers receivedLotto) {
+    Map<WinningCheck, Integer> result = new HashMap<>(); // WinningCheck 객체 정수를 키와 값으로 Map에 저장
+    for (Lotto lotto : lottos) {
+      int matchCount = lotto.getMatchCount(receivedLotto);
+      boolean bonusMatch = lotto.isBonusMatch(receivedLotto); // receivedLotto는 bonus를 포함하고있음
+
+      WinningCheck prize = WinningCheck.getPrize(matchCount, bonusMatch);
+      result.merge(prize, 1, Integer::sum);
+    }
+    return result;
+  }
+}