스프링 월요일 [B팀] (김준호) 미션 제출합니다.

src/main/java/lotto/Application.java

@@ -1,7 +1,12 @@
 package lotto;
 
+import lotto.controller.LottoController;
+
 public class Application {
+
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+
+        LottoController lottoController = new LottoController();
+        lottoController.lottoStart();
     }
-}
+}

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

@@ -0,0 +1,38 @@
+package lotto.controller;
+
+import lotto.domain.*;
+import lotto.view.OutputView;
+
+import java.util.Arrays;
+import java.util.Map;
+
+public class LottoController {
+    private static final int LOTTO_PRICE = 1000;
+
+    public void lottoStart(){
+
+        final int purchaseAmount =  InputPurchaseAmount.getPurchaseAmount();
+        Lotto[] lotto = new Lotto[purchaseAmount];
+        for (int i = 0; i < purchaseAmount; i++) {
+            lotto[i] = new Lotto(CreateRandomLottoNumbers.createRandomLottoNumbers());
+        }
+        Lottos lottos = new Lottos(Arrays.stream(lotto).toList());
+        printLottoInformation(purchaseAmount,lottos);
+
+        WinningLotto winningLotto = new WinningLotto(InputWinPriceNumber.getWinPriceNumber(), InputWinPriceNumber.getLottoBonusNumber());
+        Map<WinningRank, Integer> winningDetails = WinningStatistics.getWinningDetails(lottos, winningLotto);
+        printWinningInformation(winningDetails, purchaseAmount);
+    }
+
+    private void printLottoInformation(int purchaseAmount, Lottos lottos){
+        InputPurchaseAmount.printPurchaseAmount(purchaseAmount);
+        Lottos.printLottos(lottos);
+    }
+
+    private void printWinningInformation(Map<WinningRank, Integer> winningDetails, int purchaseAmount) {
+        OutputView.printWinningStatistics();
+        OutputView.printWinningDetails(winningDetails);
+        long winningAmount = WinningStatistics.getWinningAmount(winningDetails);
+        OutputView.printLottoYield(WinningStatistics.getLottoYield(winningAmount, purchaseAmount*LOTTO_PRICE));
+    }
+}

src/main/java/lotto/domain/CreateRandomLottoNumbers.java

@@ -0,0 +1,11 @@
+package lotto.domain;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.List;
+
+public class CreateRandomLottoNumbers {
+    public static List<Integer> createRandomLottoNumbers() {
+        return SortLottoNumber.sortNumbers(Randoms.pickUniqueNumbersInRange(1, 45, 6));
+    }
+}

src/main/java/lotto/domain/InputPurchaseAmount.java

@@ -0,0 +1,17 @@
+package lotto.domain;
+
+import camp.nextstep.edu.missionutils.Console;
+
+public class InputPurchaseAmount {
+    private static final String HOW_MANY_LOTTO_USER_PURCHASED_MESSAGE = "%d개를 구매했습니다.\n";
+    private static final String PURCHASE_AMOUNT_MESSAGE = "구입금액을 입력해 주세요.";
+    public static int getPurchaseAmount() {
+        System.out.println(PURCHASE_AMOUNT_MESSAGE);
+        String str = Console.readLine();
+        return Integer.parseInt(str) / 1000;
+    }
+
+    public static void printPurchaseAmount(int purchaseAmount){
+        System.out.printf(HOW_MANY_LOTTO_USER_PURCHASED_MESSAGE, purchaseAmount);
+    }
+}

src/main/java/lotto/domain/InputWinPriceNumber.java

@@ -0,0 +1,33 @@
+package lotto.domain;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static camp.nextstep.edu.missionutils.Console.readLine;
+import static lotto.domain.SortLottoNumber.sortNumbers;
+
+public class InputWinPriceNumber {
+
+    private static final String LOTTO_NUMBER_MESSAGE = "당첨 번호를 입력해 주세요.";
+    private static final String LOTTO_BONUS_NUMBER_MESSAGE = "보너스 번호를 입력해 주세요.";
+
+
+    public static List<Integer> getWinPriceNumber() {
+        List<Integer> numbers = new ArrayList<>();
+        System.out.println(LOTTO_NUMBER_MESSAGE);
+        String[] str = readLine().split(",");
+
+        for (int i = 0; i < 6; i++) {
+            numbers.add(Integer.parseInt(str[i]));
+        }
+
+        sortNumbers(numbers);
+        return numbers;
+    }
+
+    public static int getLottoBonusNumber() {
+        System.out.println(LOTTO_BONUS_NUMBER_MESSAGE);
+        return Integer.parseInt(readLine());
+    }
+}

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

@@ -0,0 +1,37 @@
+package lotto.domain;
+
+import java.util.List;
+
+public class Lotto {
+    private final List<Integer> numbers;
+    private static final String LOTTO_NUMBERS_MUST_BE_SIX_DIFFERENT_NUMBERS = "[ERROR] 로 번호는 서로 다른 6개의 수여야 합니다.";
+    private static final String LOTTO_NUMBERS_MUST_BE_SIX_UNIQUE_NUMBERS = "[ERROR] 로또 번호는 중복된 수가 있으면 안됩니다.";
+
+    public Lotto(List<Integer> numbers) {
+        validate(numbers);
+        validateDuplicate(numbers);
+        this.numbers = numbers;
+    }
+
+    private void validate(List<Integer> numbers) {
+        if (numbers.size() != 6) {
+            System.out.println(LOTTO_NUMBERS_MUST_BE_SIX_DIFFERENT_NUMBERS);
+            throw new IllegalArgumentException();
+        }
+    }
+
+    private void validateDuplicate(List<Integer> numbers){
+        if(numbers.size() != numbers.stream().distinct().count()){
+            System.out.println(LOTTO_NUMBERS_MUST_BE_SIX_UNIQUE_NUMBERS);
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public void printNumbers(){
+        System.out.println(numbers);
+    }
+
+    public List<Integer> getNumbers() {
+        return numbers;
+    }
+}

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

@@ -0,0 +1,21 @@
+package lotto.domain;
+
+import java.util.List;
+
+public class Lottos {
+
+    private List<Lotto> lottos;
+
+    public Lottos(List<Lotto> lottos) {
+        this.lottos = lottos;
+    }
+
+    public List<Lotto> getLottos() {
+        return lottos;
+    }
+
+    public static void printLottos(Lottos lottos) {
+        lottos.getLottos().stream()
+                .forEach(lotto -> System.out.println(lotto.getNumbers().toString()));
+    }
+}

src/main/java/lotto/domain/SortLottoNumber.java

@@ -0,0 +1,11 @@
+package lotto.domain;
+
+import java.util.Collections;
+import java.util.List;
+
+public class SortLottoNumber {
+    public static List<Integer> sortNumbers(List<Integer> numbers){
+        Collections.sort(numbers);
+        return numbers;
+    }
+}

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

@@ -0,0 +1,74 @@
+package lotto.domain;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class WinningLotto {
+
+    private static final String WINNING_NUMBERS_ARE_BETWEEN_ONE_AND_FORTY_FIVE = "[ERROR] 당첨 번호는 1부터 45 사이의 숫자여야 합니다.";
+    private static final String WINNING_NUMBERS_MUST_BE_SIX_DIFFERENT_NUMBERS = "[ERROR] 당첨 번호는 서로 다른 6개의 수여야 합니다.";
+    private static final String BONUS_NUMBER_IS_BETWEEN_ONE_AND_FORTY_FIVE = "[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.";
+    private static final String WINNING_NUMBERS_CONTAIN_BONUS_NUMBER = "[ERROR] 당첨 번호와 보너스 번호가 중복됩니다.";
+    private static final int LOTTO_NUMBER_LOWER_LIMIT = 1;
+    private static final int LOTTO_NUMBER_UPPER_LIMIT = 45;
+    private static final int LOTTO_NUMBERS_SIZE = 6;
+
+    private final List<Integer> winningNumbers;
+    private final int bonusNumber;
+
+    public WinningLotto(List<Integer> winningNumbers, int bonusNumber) {
+        validateWinningNumbers(winningNumbers);
+        validateBonusNumber(bonusNumber);
+        validateDuplicate(winningNumbers, bonusNumber);
+        this.winningNumbers = winningNumbers;
+        this.bonusNumber = bonusNumber;
+    }
+
+    private void validateWinningNumbers(List<Integer> winningNumbers) {
+        if (!isSixDifferentNumbers(winningNumbers)) {
+            throw new IllegalArgumentException(WINNING_NUMBERS_MUST_BE_SIX_DIFFERENT_NUMBERS);
+        }
+        if (!isBetweenOneAndFortyFive(winningNumbers)) {
+            throw new IllegalArgumentException(WINNING_NUMBERS_ARE_BETWEEN_ONE_AND_FORTY_FIVE);
+        }
+    }
+
+    private boolean isBetweenOneAndFortyFive(List<Integer> winningNumbers) {
+        for (int winningNumber : winningNumbers) {
+            if (winningNumber < LOTTO_NUMBER_LOWER_LIMIT || winningNumber > LOTTO_NUMBER_UPPER_LIMIT) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean isSixDifferentNumbers(List<Integer> winningNumbers) {
+        Set<Integer> duplicateChecker = new HashSet<>(winningNumbers);
+        return duplicateChecker.size() == LOTTO_NUMBERS_SIZE;
+    }
+
+    private void validateBonusNumber(int bonusNumber) {
+        if (!isBetweenOneAndFortyFive(bonusNumber)) {
+            throw new IllegalArgumentException(BONUS_NUMBER_IS_BETWEEN_ONE_AND_FORTY_FIVE);
+        }
+    }
+
+    private boolean isBetweenOneAndFortyFive(int bonusNumber) {
+        return bonusNumber >= LOTTO_NUMBER_LOWER_LIMIT && bonusNumber <= LOTTO_NUMBER_UPPER_LIMIT;
+    }
+
+    private void validateDuplicate(List<Integer> winningNumbers, int bonusNumber) {
+        if (winningNumbers.contains(bonusNumber)) {
+            throw new IllegalArgumentException(WINNING_NUMBERS_CONTAIN_BONUS_NUMBER);
+        }
+    }
+
+    public List<Integer> getWinningNumbers() {
+        return winningNumbers;
+    }
+
+    public int getBonusNumber() {
+        return bonusNumber;
+    }
+}

src/main/java/lotto/domain/WinningRank.java

@@ -0,0 +1,39 @@
+package lotto.domain;
+
+import java.util.Arrays;
+
+public enum WinningRank {
+
+    LAST_PLACE(0, false, 0),
+    FIFTH_PLACE(3, false, 5_000),
+    FOURTH_PLACE(4, false, 50_000),
+    THIRD_PLACE(5, false, 1_500_000),
+    SECOND_PLACE(5, true, 30_000_000),
+    FIRST_PLACE(6, false, 2_000_000_000);
+
+    private final int matchingCount;
+    private final boolean containsBonusNumber;
+    private final int winningPrice;
+
+    WinningRank(int matchingCount, boolean containsBonusNumber, int winningPrice) {
+        this.matchingCount = matchingCount;
+        this.containsBonusNumber = containsBonusNumber;
+        this.winningPrice = winningPrice;
+    }
+
+    public static WinningRank findWinningRank(int matchingCount, boolean containsBonusNumber) {
+        return Arrays.stream(values())
+                .filter(winningRank -> winningRank.matchingCount == matchingCount)
+                .filter(winningRank -> winningRank.containsBonusNumber == containsBonusNumber)
+                .findFirst()
+                .orElse(WinningRank.LAST_PLACE);
+    }
+
+    public int getMatchingCount() {
+        return matchingCount;
+    }
+
+    public int getWinningPrice() {
+        return winningPrice;
+    }
+}

src/main/java/lotto/domain/WinningStatistics.java

@@ -0,0 +1,58 @@
+package lotto.domain;
+
+import java.util.Arrays;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+public class WinningStatistics {
+
+    private static final int AT_LEAST_THIRD_PLACE = 5;
+    private static final int PERCENTAGE = 100;
+    private static final int INITIAL_VALUE = 0;
+
+    public static Map<WinningRank, Integer> getWinningDetails(Lottos lottos, WinningLotto winningLotto) {
+        Map<WinningRank, Integer> winningDetails = generateWinningDetails();
+        for (Lotto lotto : lottos.getLottos()) {
+            int matchingCount = compareNumbersWithWinningNumbers(lotto, winningLotto);
+            boolean containsBonusNumber = compareNumbersWithBonusNumber(lotto, winningLotto, matchingCount);
+            WinningRank winningRank = WinningRank.findWinningRank(matchingCount, containsBonusNumber);
+            winningDetails.replace(winningRank, winningDetails.get(winningRank) + 1);
+        }
+        return winningDetails;
+    }
+
+    public static Map<WinningRank, Integer> generateWinningDetails() {
+        Map<WinningRank, Integer> winningDetails = new EnumMap<>(WinningRank.class);
+        Arrays.stream(WinningRank.values()).forEach(winningRank -> winningDetails.put(winningRank, INITIAL_VALUE));
+        return winningDetails;
+    }
+
+    private static int compareNumbersWithWinningNumbers(Lotto lotto, WinningLotto winningLotto) {
+        List<Integer> numbers = lotto.getNumbers();
+        List<Integer> winningNumbers = winningLotto.getWinningNumbers();
+        return (int) numbers.stream()
+                .filter(winningNumbers::contains)
+                .count();
+    }
+
+    private static boolean compareNumbersWithBonusNumber(Lotto lotto, WinningLotto winningLotto, int matchingCount) {
+        if (matchingCount != AT_LEAST_THIRD_PLACE) {
+            return false;
+        }
+        List<Integer> numbers = lotto.getNumbers();
+        int bonusNumber = winningLotto.getBonusNumber();
+        return numbers.contains(bonusNumber);
+    }
+
+    public static long getWinningAmount(Map<WinningRank, Integer> winningDetails) {
+        return winningDetails.entrySet().stream()
+                .mapToLong(entry -> (long) entry.getKey().getWinningPrice() * entry.getValue())
+                .sum();
+    }
+
+    public static double getLottoYield(long winningAmount, int money) {
+        double lottoYield = PERCENTAGE + (double) (winningAmount - money) / money * PERCENTAGE;
+        return Math.round(lottoYield * 10) / 10.0;
+    }
+}