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

docs/README.md

@@ -0,0 +1,29 @@
+Application과 동일 선상에 RunLotto 클래스 생성
+
+RunLotto에 필요한 기능들을 패키지로 묶어보자
+
+- 도메인 모델 패키지 (domain)
+    - 사용자로부터 입력받은 구입금액을 저장하는 클래스 PurchaseAmount
+    - 난수 생성된 로또 번호가 있는 클래스 Lotto
+    - 사용자로부터 로또 번호 6개와 보너스 번호 1개를 입력받아 저장하는 클래스 UserInputNumbers
+    - 상금과 당첨 수를 저장하는 열거형 enum WinningCheck
+- 비즈니스 로직을 수행하는 서비스 패키지 (service)
+    - 당첨 결과와 수익률을 계산하는 클래스 Calculator
+    - 구입금액만큼 로또를 발행하는 클래스 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) {
+    RunLotto runLotto = new RunLotto();
+    runLotto.runLotto();
+  }
 }

src/main/java/lotto/RunLotto.java

@@ -0,0 +1,34 @@
+package lotto;
+
+import java.util.List;
+import java.util.Map;
+import lotto.domain.Lotto;
+import lotto.domain.PurchaseAmount;
+import lotto.domain.UserInputNumbers;
+import lotto.sevice.Calculator;
+import lotto.util.InputManager;
+import lotto.sevice.LottoGenerator;
+import lotto.util.OutputManager;
+import lotto.domain.WinningCheck;
+
+public class RunLotto {
+
+  private final InputManager inputManager = new InputManager();
+  private final LottoGenerator lottoGenerator = new LottoGenerator();
+  private final Calculator calculator = new Calculator();
+  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 = calculator.calculateWinningResult(generatedLottos,
+        userInputNumbers);
+    double profitRate = calculator.calculateProfitRate(purchaseAmount, result);
+
+    outputManager.printResults(result, profitRate);
+  }
+}

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

@@ -0,0 +1,49 @@
+package lotto.domain;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+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("[ERROR] 로또 번호는 총 6개여야 합니다.");
+    }
+
+    for (int number : lottoNumbers) {
+      if (number < MIN_LOTTO_NUMBER || number > MAX_LOTTO_NUMBER) {
+        throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+      }
+    }
+
+    Set<Integer> uniqueNumbers = new HashSet<>(lottoNumbers);
+    if (uniqueNumbers.size() < lottoNumbers.size()) {
+      throw new IllegalArgumentException("[ERROR] 로또 번호는 중복이 없어야 합니다.");
+    }
+  }
+
+  public List<Integer> getLottoNumbers() {
+    return lottoNumbers;
+  }
+}

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

@@ -0,0 +1,32 @@
+package lotto.domain;
+
+public class PurchaseAmount {
+
+  public static final int LOTTO_PRICE = 1000;
+  private int amount;
+
+  public PurchaseAmount(String input) {
+    validateIsNumeric(input);
+    int inputAmount = Integer.parseInt(input);
+    validatePurchaseAmount(amount);
+    this.amount = inputAmount;
+  }
+
+  private static void validateIsNumeric(String inputAmount) {
+    try {
+      Integer.parseInt(inputAmount);
+    } catch (NumberFormatException e) {
+      throw new IllegalArgumentException("[ERROR] 구입금액은 숫자여야합니다.");
+    }
+  }
+
+  private static void validatePurchaseAmount(int inputAmount) {
+    if (inputAmount % LOTTO_PRICE != 0) {
+      throw new IllegalArgumentException("[ERROR] 1000 단위의 금액을 입력하세요.");
+    }
+  }
+
+  public int getAmount() {
+    return amount;
+  }
+}

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

@@ -0,0 +1,57 @@
+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;
+
+public class UserInputNumbers {
+
+  private List<Integer> receivedLottoNumbers;
+  private 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("[ERROR] 로또 번호는 총 6개여야 합니다.");
+    }
+
+    for (int number : receivedLottoNumbers) {
+      if (number < MIN_LOTTO_NUMBER || number > MAX_LOTTO_NUMBER) {
+        throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+      }
+    }
+
+    Set<Integer> uniqueNumbers = new HashSet<>(receivedLottoNumbers);
+    if (uniqueNumbers.size() < receivedLottoNumbers.size()) {
+      throw new IllegalArgumentException("[ERROR] 로또 번호는 중복이 없어야 합니다.");
+    }
+  }
+
+  private void validateBonusNumbers(int bonusNumber) {
+    if (bonusNumber < MIN_LOTTO_NUMBER || bonusNumber > MAX_LOTTO_NUMBER) {
+      throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+    }
+
+    if (new HashSet<>(receivedLottoNumbers).contains(bonusNumber)) {
+      throw new IllegalArgumentException("[ERROR] 로또 번호는 중복이 없어야 합니다.");
+    }
+  }
+
+  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(5000, 3),
+  FOURTH_PRIZE(50000, 4),
+  THIRD_PRIZE(1500000, 5, false),
+  SECOND_PRIZE(30000000, 5, true),
+  FIRST_PRIZE(2000000000, 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/sevice/Calculator.java

@@ -0,0 +1,42 @@
+package lotto.sevice;
+
+import java.text.DecimalFormat;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import lotto.domain.Lotto;
+import lotto.domain.PurchaseAmount;
+import lotto.domain.UserInputNumbers;
+import lotto.domain.WinningCheck;
+
+public class Calculator {
+
+  private static final int PERCENTAGE_FACTOR = 100;
+
+  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;
+  }
+
+  public double calculateProfitRate(PurchaseAmount purchaseAmount,
+      Map<WinningCheck, Integer> result) {
+    double totalPrize = 0;
+    for (Map.Entry<WinningCheck, Integer> entry : result.entrySet()) {
+      WinningCheck prize = entry.getKey();
+      int count = entry.getValue();
+      totalPrize += prize.getPrizeAmount() * count;
+    }
+
+    double profitRate = (totalPrize / purchaseAmount.getAmount()) * PERCENTAGE_FACTOR;
+    DecimalFormat df = new DecimalFormat("#.##");
+    return Double.parseDouble(df.format(profitRate));
+  }
+}

src/main/java/lotto/sevice/LottoGenerator.java

@@ -0,0 +1,38 @@
+package lotto.sevice;
+
+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.getAmount() / 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;
+  }
+
+}