2주차 - Step4 로또(수동) 리뷰 요청드립니다.

src/main/java/step4/LottoApplication.java

@@ -0,0 +1,29 @@
+package step4;
+
+import step4.domain.*;
+import step4.view.InputView;
+import step4.view.OutputView;
+
+import java.util.List;
+
+public class LottoApplication {
+
+    public static void main(String[] args) {
+        final int inputMoney = InputView.askMoneyToInput();
+        final int numberOfManualTickets = InputView.askNumberOfManualTicket();
+        final int numberOfAutoTickets = LottoSeller.countAutoTickets(inputMoney, numberOfManualTickets);
+
+        List<String> manualTickets = InputView.askNumbersForManualTickets(numberOfManualTickets);
+        OutputView.printNumberOfTickets(numberOfManualTickets, numberOfAutoTickets);
+
+        LottoTickets lottoTickets = LottoSeller.issueLottoTicket(manualTickets, numberOfAutoTickets);
+        OutputView.printLottoTickets(lottoTickets);
+
+        LuckyTicket luckyTicket = LottoSeller
+                .getLuckyNumber(InputView.askLuckyNumber(), InputView.askBonusNumber());
+
+        ResultSheet result = ResultSheet.getResult(lottoTickets, luckyTicket);
+        OutputView.printResult(result);
+    }
+}
+

src/main/java/step4/domain/LottoBalls.java

@@ -0,0 +1,17 @@
+package step4.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class LottoBalls {
+
+    private static List<Integer> lottoBalls = IntStream
+            .rangeClosed(LottoNumber.MINIMUM_LOTTO_NUMBER, LottoNumber.MAXIMUM_LOTTO_NUMBER)
+            .boxed()
+            .collect(Collectors.toList());
+
+    static List<Integer> getLottoBalls() {
+        return lottoBalls;
+    }
+}

src/main/java/step4/domain/LottoNumber.java

@@ -0,0 +1,47 @@
+package step4.domain;
+
+import java.util.Objects;
+
+public class LottoNumber {
+    static final String ALERT_OUT_OF_RANGE_OF_LOTTO_NUMBER = "로또번호는 1부터 45까지의 자연수만 가능합니다.";
+    static final int MINIMUM_LOTTO_NUMBER = 1;
+    static final int MAXIMUM_LOTTO_NUMBER = 45;
+    private int number;
+
+    private LottoNumber(int number) {
+        if (isOutOfRange(number)) {
+            throw new IllegalArgumentException(ALERT_OUT_OF_RANGE_OF_LOTTO_NUMBER);
+        }
+        this.number = number;
+    }
+
+    public static LottoNumber from(Integer number) {
+        return new LottoNumber(number);
+    }
+
+    private boolean isOutOfRange(int number) {
+        return number < MINIMUM_LOTTO_NUMBER || number > MAXIMUM_LOTTO_NUMBER;
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        LottoNumber that = (LottoNumber) o;
+        return number == that.number;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(number);
+    }
+
+    @Override
+    public String toString() {
+        return number + "";
+    }
+}

src/main/java/step4/domain/LottoRank.java

@@ -0,0 +1,44 @@
+package step4.domain;
+
+import java.util.Arrays;
+
+public enum LottoRank {
+
+    FIRST_PLACE(6, 2_000_000_000),
+    SECOND_PLACE(5, 30_000_000),
+    THIRD_PLACE(5, 1_500_000),
+    FOURTH_PLACE(4, 50_000),
+    FIFTH_PLACE(3, 5_000),
+    LOSER(0, 0);
+
+    private int numberOfMatchedToLuckyNumber;
+    private int prizeMoney;
+
+    LottoRank(int numberOfMatchedToLuckyNumber, int prizeMoney) {
+        this.numberOfMatchedToLuckyNumber = numberOfMatchedToLuckyNumber;
+        this.prizeMoney = prizeMoney;
+    }
+
+    public static LottoRank from(LottoTicket lottoTicket, LuckyTicket luckyTicket) {
+        int countMatchedNumbers = lottoTicket.getNumberOfMatchedToLuckyNumber(luckyTicket);
+        boolean isMatchedToBonusNumber = lottoTicket.isBonusNumberMatched(luckyTicket);
+
+        if ((countMatchedNumbers == SECOND_PLACE.numberOfMatchedToLuckyNumber) && isMatchedToBonusNumber) {
+            return LottoRank.SECOND_PLACE;
+        }
+        return Arrays.stream(LottoRank.values())
+                .filter(lottoRank -> lottoRank.numberOfMatchedToLuckyNumber == countMatchedNumbers)
+                .filter(lottoRank -> lottoRank.prizeMoney != SECOND_PLACE.prizeMoney)
+                .findFirst()
+                .orElse(LOSER);
+    }
+
+    public int getNumberOfMatchingNumber() {
+        return numberOfMatchedToLuckyNumber;
+    }
+
+    public int getPrizeMoney() {
+        return prizeMoney;
+    }
+
+}

src/main/java/step4/domain/LottoSeller.java

@@ -0,0 +1,59 @@
+package step4.domain;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class LottoSeller {
+    static final int PRICE_OF_A_LOTTO_TICKET = 1000;
+    static final String ALERT_MISSING_MONEY = "돈을 넣어주세요. 로또복권은 한 장당 1000원 입니다.";
+    private static final String ALERT_SHORT_OF_MONEY = "돈이 모자랍니다.";
+    private static final String ALERT_NEGATIVE_NUMBER = "구매할 수동로또 개수는 음수가 될 수 없습니다.";
+    static final String NUMBER_SEPARATOR = ",";
+
+    public static int countAutoTickets(int inputMoney, int numberOfManualTickets) {
+        validationInputData(inputMoney, numberOfManualTickets);
+        return (inputMoney / PRICE_OF_A_LOTTO_TICKET) - numberOfManualTickets;
+    }
+
+    public static LottoTickets issueLottoTicket(List<String> manualTickets, int numberOfAutoTickets) {
+        List<LottoTicket> lottoTickets = new ArrayList<>();
+
+        for (String manualTicket : manualTickets) {
+            List<Integer> parsedManualTicket = parseToNumbers(manualTicket);
+            lottoTickets.add(LottoTicketGenerator.issueManualTickets(parsedManualTicket));
+        }
+        for (int i = 0; i < numberOfAutoTickets; i++) { //TODO: index i가 사용되지 않고 있음
+            lottoTickets.add(LottoTicketGenerator.issueAutoTickets());
+        }
+        return LottoTickets.from(lottoTickets);
+    }
+
+    private static List<Integer> parseToNumbers(String manualTicket) {
+        return Arrays.stream(manualTicket.split(NUMBER_SEPARATOR))
+                .map(String::trim)
+                .mapToInt(Integer::parseInt)
+                .boxed()
+                .collect(Collectors.toList());
+    }
+
+    public static LuckyTicket getLuckyNumber(List<Integer> inputLuckyNumber, int bonusNumber) {
+        List<LottoNumber> luckyTicket = inputLuckyNumber.stream()
+                .map(LottoNumber::from)
+                .collect(Collectors.toList());
+        return LuckyTicket.of(luckyTicket, LottoNumber.from(bonusNumber));
+    }
+
+    private static void validationInputData(int inputMoney, int numberOfManualTickets) {
+        if (inputMoney < PRICE_OF_A_LOTTO_TICKET) {
+            throw new IllegalArgumentException(ALERT_MISSING_MONEY);
+        }
+        if (numberOfManualTickets < 0) {
+            throw new IllegalArgumentException(ALERT_NEGATIVE_NUMBER);
+        }
+        if (numberOfManualTickets * PRICE_OF_A_LOTTO_TICKET > inputMoney) {
+            throw new IllegalArgumentException(ALERT_SHORT_OF_MONEY);
+        }
+    }
+}

src/main/java/step4/domain/LottoTicket.java

@@ -0,0 +1,69 @@
+package step4.domain;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public class LottoTicket {
+    static final String ALERT_NUMBER_OVERLAP = "중복된 로또 번호가 존재합니다.";
+    static final String AlERT_DIFFERENT_SIZE_OF_NUMBERS = "로또번호의 개수가 6개가 아닙니다.";
+
+    private final List<LottoNumber> lottoTicket;
+
+    LottoTicket(List<LottoNumber> lottoTicket) {
+        validationNumberSize(lottoTicket);
+        validationNumberOverlap(lottoTicket);
+        this.lottoTicket = lottoTicket;
+    }
+
+    public int getNumberOfMatchedToLuckyNumber(LuckyTicket luckyTicket) {
+        return (int) luckyTicket.getLuckyNumber().stream()
+                .filter(lottoTicket::contains)
+                .count();
+    }
+
+    boolean isBonusNumberMatched(LuckyTicket luckyTicket) {
+        return luckyTicket.checkBonusNumber(lottoTicket);
+    }
+
+    private void validationNumberSize(List<LottoNumber> lottoTicket) {
+        if (lottoTicket.size() != LottoTicketGenerator.BASIC_LOTTO_SIZE) {
+            throw new IllegalArgumentException(AlERT_DIFFERENT_SIZE_OF_NUMBERS);
+        }
+    }
+
+    private void validationNumberOverlap(List<LottoNumber> lottoTicket) {
+        long SizeOfLottoTicket = lottoTicket.stream()
+                .mapToLong(LottoNumber::getNumber)
+                .distinct()
+                .count();
+
+        if (SizeOfLottoTicket != LottoTicketGenerator.BASIC_LOTTO_SIZE) {
+            throw new IllegalArgumentException(ALERT_NUMBER_OVERLAP);
+        }
+    }
+
+    public List<LottoNumber> getLottoTicket() {
+        return Collections.unmodifiableList(lottoTicket);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        LottoTicket that = (LottoTicket) o;
+        return Objects.equals(lottoTicket, that.lottoTicket);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(lottoTicket);
+    }
+
+    @Override
+    public String toString() {
+        return "LottoTicket{" +
+                "lottoTicket=" + lottoTicket +
+                '}';
+    }
+}

src/main/java/step4/domain/LottoTicketGenerator.java

@@ -0,0 +1,34 @@
+package step4.domain;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class LottoTicketGenerator {
+    static final int BASIC_LOTTO_SIZE = 6;
+
+    static LottoTicket issueAutoTickets() {
+        return new LottoTicket(pickLottoBalls(LottoBalls.getLottoBalls()));
+    }
+
+    static LottoTicket issueManualTickets(List<Integer> manualTicket) {
+        return new LottoTicket(manualTicket.stream()
+                .sorted()
+                .map(LottoNumber::from)
+                .collect(Collectors.toList()));
+    }
+
+    static List<LottoNumber> pickLottoBalls(List<Integer> lottoBalls) {
+        shuffleLottoBalls(lottoBalls);
+        return lottoBalls.stream()
+                .limit(BASIC_LOTTO_SIZE)
+                .sorted()
+                .map(LottoNumber::from)
+                .collect(Collectors.toList());
+    }
+
+    static void shuffleLottoBalls(List<Integer> lottoBalls) {
+        Collections.shuffle(lottoBalls);
+    }
+
+}

src/main/java/step4/domain/LottoTickets.java

@@ -0,0 +1,20 @@
+package step4.domain;
+
+import java.util.Collections;
+import java.util.List;
+
+public class LottoTickets {
+    private final List<LottoTicket> lottoTickets;
+
+    private LottoTickets(List<LottoTicket> lottoTickets) {
+        this.lottoTickets = lottoTickets;
+    }
+
+    public static LottoTickets from(List<LottoTicket> lottoTickets) {
+        return new LottoTickets(lottoTickets);
+    }
+
+    public List<LottoTicket> getLottoTickets() {
+        return Collections.unmodifiableList(lottoTickets);
+    }
+}

src/main/java/step4/domain/LuckyTicket.java

@@ -0,0 +1,26 @@
+package step4.domain;
+
+import java.util.Collections;
+import java.util.List;
+
+public class LuckyTicket {
+    private final List<LottoNumber> luckyNumber;
+    private final LottoNumber bonusNumber;
+
+    private LuckyTicket(List<LottoNumber> luckyNumber, LottoNumber bonusNumber) {
+        this.luckyNumber = luckyNumber;
+        this.bonusNumber = bonusNumber;
+    }
+
+    static LuckyTicket of(List<LottoNumber> luckyNumber, LottoNumber bonusNumber) {
+        return new LuckyTicket(luckyNumber, bonusNumber);
+    }
+
+    public List<LottoNumber> getLuckyNumber() {
+        return Collections.unmodifiableList(luckyNumber);
+    }
+
+    boolean checkBonusNumber(List<LottoNumber> lottoTicket) {
+        return lottoTicket.contains(bonusNumber);
+    }
+}