[미션 2] 로또 게임 구현 완료했습니다. 리뷰 부탁드립니다.

src/main/java/Lotto/Lotto.java

@@ -0,0 +1,57 @@
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Lotto {
+    private final static int LOTTO_NUM_SIZE = 6;
+    private final List<LottoNo> lottoNums;
+
+    public Lotto(List<LottoNo> lottoNums) {
+        checkSizeValid(lottoNums);
+        checkNumbersValid(lottoNums);
+        checkDuplicated(lottoNums);
+
+        this.lottoNums = lottoNums;
+    }
+
+    public List<Integer> getNums() {
+        List<Integer> lottoNumbers = new ArrayList<>();
+
+        for (LottoNo lottoNo : lottoNums) {
+            lottoNumbers.add(lottoNo.getLottoNumber());
+        }
+
+        return lottoNumbers;
+    }
+
+    public List<LottoNo> getLottoNums() {
+        return lottoNums;
+    }
+
+    public void checkSizeValid(List<LottoNo> lotto) {
+        if (!isValidLottoSize(lotto)) {
+            throw new IllegalArgumentException("6개의 로또 번호를 입력해 주세요.");
+        }
+    }
+
+    public void checkNumbersValid(List<LottoNo> lotto) {
+        if (lotto.contains(LottoNo.INVALID_LOTTO_NO)) {
+            throw new IllegalArgumentException("1 ~ 45 안의 정수를 입력하세요.");
+        }
+    }
+
+    public void checkDuplicated(List<LottoNo> lotto) {
+        if (!isValidLottoSize(new HashSet<>(lotto))) {
+            throw new IllegalArgumentException("로또 번호는 중복될 수 없습니다.");
+        }
+    }
+
+    boolean isValidLottoSize(List<LottoNo> lotto) {
+        return lotto.size() == LOTTO_NUM_SIZE;
+    }
+
+    boolean isValidLottoSize(Set<LottoNo> lotto) {
+        return lotto.size() == LOTTO_NUM_SIZE;
+    }
+}

src/main/java/Lotto/LottoNo.java

@@ -0,0 +1,46 @@
+import java.util.Objects;
+
+public class LottoNo implements Comparable<LottoNo> {
+    private final static int INVALID_NUM = 0;
+    public final static LottoNo INVALID_LOTTO_NO = new LottoNo(INVALID_NUM);
+
+    private int lottoNumber;
+
+    public LottoNo(int lottoNumber) {
+        try {
+            this.lottoNumber = validateLottoNo(lottoNumber);
+        } catch (IllegalArgumentException e) {
+            this.lottoNumber = INVALID_NUM;
+        }
+    }
+
+    public int getLottoNumber() {
+        return lottoNumber;
+    }
+
+    private int validateLottoNo(int lottoNumber) {
+        if (lottoNumber < 1 || lottoNumber > 45) {
+            throw new IllegalArgumentException();
+        }
+
+        return lottoNumber;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(lottoNumber);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (lottoNumber == ((LottoNo)obj).lottoNumber)
+            return true;
+
+        return false;
+    }
+
+    @Override
+    public int compareTo(LottoNo o) {
+        return lottoNumber - o.lottoNumber;
+    }
+}

src/main/java/Lotto/LottoRankResult.java

@@ -0,0 +1,40 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class LottoRankResult {
+    private List<Rank> ranks;
+
+    public LottoRankResult(WinningLotto winningLotto, LottoTicket lottoTicket) {
+        this.ranks = new ArrayList<>();
+
+        for (Lotto lotto : lottoTicket.getAllLottoGames()) {
+            ranks.add(
+                    Rank.valueOf(
+                            winningLotto.getCountOfSameNumber(lotto),
+                            winningLotto.isWinningBonus(lotto)
+                    )
+            );
+        }
+    }
+
+    public int getCount(Rank rank) {
+        return (int) ranks.stream().filter(t -> t.equals(rank)).count();
+    }
+
+    public Money getTotalWinningMoney() {
+        Money earnings = Money.ZERO;
+
+        for (Rank rank : ranks) {
+            earnings = earnings.add(rank.getWinningMoney());
+        }
+
+        return earnings;
+    }
+
+    public double getEarningsRate(Money invest) {
+        Money earnings = getTotalWinningMoney();
+
+        return (double)(earnings.intValue()) / invest.intValue() * 100.0;
+    }
+
+}

src/main/java/Lotto/Lottos.java

@@ -0,0 +1,22 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Lottos {
+    private List<Lotto> lottos;
+
+    public Lottos() {
+        this.lottos = new ArrayList<>();
+    }
+
+    public List<Lotto> getLottos() {
+        return lottos;
+    }
+
+    public void addLotto(Lotto lotto) {
+        lottos.add(lotto);
+    }
+
+    public int getSize() {
+        return lottos.size();
+    }
+}

src/main/java/Lotto/WinningLotto.java

@@ -0,0 +1,29 @@
+import java.util.List;
+
+public class WinningLotto {
+    private Lotto winningLotto;
+    private LottoNo bonusNo;
+
+    public WinningLotto(List<LottoNo> winningLottoNumbers, LottoNo lottoNo) {
+        if (winningLottoNumbers == null) {
+            throw new IllegalArgumentException("'lotto' must not be null");
+        }
+        if (lottoNo == null) {
+            throw new IllegalArgumentException("'lottoNo' must not be null");
+        }
+
+        this.winningLotto = new Lotto(winningLottoNumbers);
+        this.bonusNo = lottoNo;
+    }
+
+    public int getCountOfSameNumber(Lotto purchasedLotto) {
+        return (int) winningLotto.getLottoNums()
+                .stream()
+                .filter(purchasedLotto.getLottoNums()::contains)
+                .count();
+    }
+
+    public boolean isWinningBonus(Lotto purchasedLotto) {
+        return purchasedLotto.getLottoNums().contains(bonusNo);
+    }
+}

src/main/java/Main/LottoApplication.java

@@ -0,0 +1,43 @@
+import java.util.Scanner;
+
+public class LottoApplication {
+    private static boolean APP_SUCCESS = false;
+
+    public static void main(String[] args) {
+        runUntilAppSuccess();
+    }
+
+    public static void runUntilAppSuccess() {
+        while (!APP_SUCCESS) {
+            run();
+        }
+    }
+
+    public static void run() {
+        final Scanner scanner = new Scanner(System.in);
+        int countOfManualLotto;
+
+        try {
+            LottoService lottoService = new LottoService(
+                    InputView.scanMoney(scanner),
+                    countOfManualLotto = InputView.scanCountOfManualLotto(scanner),
+                    InputView.scanNumbersOfManualLotto(scanner, countOfManualLotto),
+                    new LottoSeller()
+            );
+
+            lottoService.purchaseLottoTicket();
+            lottoService.printPurchaseResult();
+
+            lottoService.setWinningLotto(
+                    InputView.scanWinningLotto(scanner),
+                    InputView.scanBonusNo(scanner)
+            );
+
+            lottoService.printWinningResult();
+
+            APP_SUCCESS = true;
+        } catch (OutOfConditionException | IllegalArgumentException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/Rank/Rank.java

@@ -0,0 +1,48 @@
+import java.util.Arrays;
+
+public enum Rank {
+    FIRST(6, 2000000000),
+    SECOND(5, 30000000),
+    THIRD(5, 1500000),
+    FOURTH(4, 50000),
+    FIFTH(3, 5000),
+    MISS(0, 0);
+
+    private int countOfMatch;
+    private Money winningMoney;
+
+    Rank(int countOfMatch, int winningMoney) {
+        this.countOfMatch = countOfMatch;
+        this.winningMoney = Money.valueOf(winningMoney);
+    }
+
+    public static Rank valueOf(int countOfGame, boolean matchBonus) {
+        if (countOfGame == SECOND.getCountOfMatch()) {
+            return getSecondOrThird(matchBonus);
+        }
+
+        return Arrays.stream(values())
+                .filter(r -> countOfGame == r.countOfMatch)
+                .findFirst()
+                .orElse(MISS);
+    }
+
+    public static Rank[] valuesNotMiss() {
+        return new Rank[]{FIRST, SECOND, THIRD, FOURTH, FIFTH};
+    }
+
+    private static Rank getSecondOrThird(boolean matchBonus) {
+        if (matchBonus)
+            return SECOND;
+        return THIRD;
+    }
+
+    public int getCountOfMatch() {
+        return countOfMatch;
+    }
+
+    public Money getWinningMoney() {
+        return winningMoney;
+    }
+
+}

src/main/java/Rank/RankResult.java

@@ -0,0 +1,21 @@
+public class RankResult {
+    private Rank rank;
+    private int countOfRank;
+
+    RankResult(Rank rank) {
+        this.rank = rank;
+        this.countOfRank = 0;
+    }
+
+    public Rank getRank() {
+        return rank;
+    }
+
+    public int getCountOfRank() {
+        return countOfRank;
+    }
+
+    public void countUp(int count) {
+        countOfRank += count;
+    }
+}

src/main/java/Service/LottoSeller.java

@@ -0,0 +1,50 @@
+import java.util.List;
+
+public class LottoSeller {
+    private LottoPurchaseService lottoPurchaseService;
+    private Money change;
+
+    public LottoSeller() {
+        change = Money.ZERO;
+        lottoPurchaseService = new LottoPurchaseService();
+    }
+
+    public LottoTicket sellTicketTo(LottoUser lottoUser) throws OutOfConditionException {
+        Money investMoney = LottoPurchaseService
+                .validatePurchase(
+                        lottoUser.getInvestMoney(),
+                        lottoUser.getCountOfManualLotto()
+                );
+
+        this.change = LottoPurchaseService
+                .calculateChange(investMoney);
+
+        return lottoPurchaseService
+                .createLottoTicket(
+                        investMoney,
+                        getCountOfAutoGame(investMoney, lottoUser.getCountOfManualLotto()),
+                        changeToLottos(lottoUser.getNumbersOfManualLottos())
+                );
+    }
+
+    public int getCountOfAutoGame(Money investMoney, int countOfManualLotto) {
+        return investMoney.divideBy(LottoPurchaseService.LOTTO_PRICE).intValue()
+                - countOfManualLotto;
+    }
+
+    private Lottos changeToLottos(List<List<LottoNo>> numbers0fManualLottos) {
+        Lottos manualLottos = new Lottos();
+
+        for (List<LottoNo> lottoNums : numbers0fManualLottos) {
+            manualLottos.addLotto(
+                    lottoPurchaseService.createManualLotto(lottoNums)
+            );
+        }
+
+        return manualLottos;
+    }
+
+    public Money getChange() {
+        return change;
+    }
+}