[1단계 - 로또(자동)] 레넌(조형래) 미션 제출합니다.

README.md

@@ -2,6 +2,25 @@
 
 로또 미션 저장소
 
+1. 구입금액을 입력받는다.
+    * 0보다 큰 숫자가 아닌 경우, RuntimeException을 발생시킨다.
+    * 1000보다 작은 수 일 경우
+2. 당첨 번호를 입력받는다.
+   * 6개가 아닌 경우
+   * 문자가 들어온 경우
+   * 1-45 사이의 수가 아닌경우
+   * 중복 숫자인 경우
+3. 보너스 번호를 입력받는다.
+  * 1-45 사이의 숫자가 아닌경우
+  * 당첨 번호와 중복된 경우
+4. 로또 번호를 자동으로 생성한다.
+5. 등수를 계산한다.
+6. 통계를 저장하고 출력한다.
+
+
+
+
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+

src/main/java/lotto/Application.java

@@ -0,0 +1,16 @@
+package lotto;
+
+import lotto.controller.LottoController;
+import lotto.model.generator.AutoLottoGenerator;
+
+public class Application {
+    public static void main(String[] args) {
+        LottoController lottoController = new LottoController(new AutoLottoGenerator());
+
+        try {
+            lottoController.run();
+        } catch (RuntimeException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}

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

@@ -0,0 +1,85 @@
+package lotto.controller;
+
+import java.util.Arrays;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import lotto.model.LottoMachine;
+import lotto.model.Money;
+import lotto.model.WinningLotto;
+import lotto.model.generator.LottoGenerator;
+import lotto.model.number.LottoNumber;
+import lotto.model.number.LottoNumbers;
+import lotto.view.InputView;
+import lotto.view.ResultView;
+
+public class LottoController {
+
+    private static final String NOT_NUMBER_ERROR_MESSAGE = "[ERROR] 문자가 입력되었습니다.";
+    private static final String NUMBER_REGEX = "\\d+";
+
+    private LottoGenerator lottoGenerator;
+
+    public LottoController(LottoGenerator lottoGenerator) {
+        this.lottoGenerator = lottoGenerator;
+    }
+
+    public void run() {
+        LottoMachine lottoMachine = new LottoMachine(lottoGenerator, validateMoney(InputView.inputMoney()));
+        ResultView.printBuyingLottosResult(lottoMachine.getLottos());
+        WinningLotto winningLotto = makeWinningLotto(InputView.inputWinningNumbers(),
+                InputView.inputBonusNumber());
+        lottoMachine.calculateResult(winningLotto);
+        ResultView.printTotalRankResult(lottoMachine);
+    }
+
+    private Money validateMoney(String money) {
+        if (!Pattern.matches(NUMBER_REGEX, money)) {
+            throw new IllegalArgumentException(Money.MONEY_ERROR_MESSAGE);
+        }
+        return new Money(Integer.parseInt(money));
+    }
+
+    private WinningLotto makeWinningLotto(String winningNumbers, String bonusNumber) {
+        LottoNumbers lottoNumbers = splitWinningNumbers(winningNumbers);
+        LottoNumber lottoBonusNumber = new LottoNumber(toIntBonusNumber(bonusNumber));
+        return new WinningLotto(lottoNumbers, lottoBonusNumber);
+    }
+
+    private LottoNumbers splitWinningNumbers(String winningNumbers) {
+        String[] splitNumbers = validateLottoNumbers(winningNumbers);
+        return new LottoNumbers(Arrays.stream(splitNumbers)
+                .map(String::trim)
+                .mapToInt(Integer::parseInt)
+                .boxed()
+                .map(LottoNumber::new)
+                .collect(Collectors.toList()));
+    }
+
+    private String[] validateLottoNumbers(String numbers) {
+        String[] splitNumbers = numbers.split(",");
+        for (String number : splitNumbers) {
+            validateNumber(number);
+        }
+        return trimLottoNumbers(splitNumbers);
+    }
+
+    private int validateNumber(String number) {
+        try {
+            String trimNumber = number.trim();
+            return Integer.parseInt(trimNumber);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(NOT_NUMBER_ERROR_MESSAGE);
+        }
+    }
+
+    private String[] trimLottoNumbers(String[] numbers) {
+        for (int i = 0; i < numbers.length; i++) {
+            numbers[i] = numbers[i].trim();
+        }
+        return numbers;
+    }
+
+    private int toIntBonusNumber(String bonusNumber) {
+        return validateNumber(bonusNumber);
+    }
+}

src/main/java/lotto/model/Lotto.java

@@ -0,0 +1,39 @@
+package lotto.model;
+
+import lotto.model.number.LottoNumber;
+import lotto.model.number.LottoNumbers;
+
+public class Lotto {
+
+    private final LottoNumbers lottoNumbers;
+    private Rank rank;
+
+    public Lotto(final LottoNumbers lottoNumbers) {
+        this.lottoNumbers = lottoNumbers;
+        this.rank = null;
+    }
+
+    public Rank calculateRank(final LottoNumbers winningNumbers, final LottoNumber bonusNumber) {
+        if (this.rank == null) {
+            int matchingCount = countMatchingNumber(winningNumbers);
+            boolean win = isWinBonusNumber(matchingCount, bonusNumber);
+            return this.rank = Rank.getRank(matchingCount, win);
+        }
+        return this.rank;
+    }
+
+    private boolean isWinBonusNumber(final int matchingCount, final LottoNumber bonusNumber) {
+        if (matchingCount == Rank.SECOND.getCount()) {
+            return lottoNumbers.containNumber(bonusNumber);
+        }
+        return false;
+    }
+
+    private int countMatchingNumber(LottoNumbers winningNumbers) {
+        return lottoNumbers.countMatchingNumber(winningNumbers);
+    }
+
+    public LottoNumbers getLottoNumbers() {
+        return lottoNumbers;
+    }
+}

src/main/java/lotto/model/LottoMachine.java

@@ -0,0 +1,40 @@
+package lotto.model;
+
+import java.util.Map;
+import lotto.model.generator.LottoGenerator;
+import lotto.model.number.LottoNumber;
+import lotto.model.number.LottoNumbers;
+
+public class LottoMachine {
+
+    private final Money money;
+    private final Lottos lottos;
+
+    private Map<Rank, Integer> rankCount;
+
+    public LottoMachine(final LottoGenerator lottoGenerator, final Money money) {
+        this.money = money;
+        this.lottos = lottoGenerator.generateLottos(money.lottoCount(), LottoNumber.LOTTO_NUMBER_MINIMUM_RANGE,
+                LottoNumber.LOTTO_NUMBER_MAXIMUM_RANGE, LottoNumbers.LOTTO_LENGTH);
+    }
+
+    public void calculateResult(final WinningLotto winningLotto) {
+        this.rankCount = winningLotto.checkRank(lottos);
+    }
+
+    public Lottos getLottos() {
+        return lottos;
+    }
+
+    public double getRevenue() {
+        int sum = 0;
+        for (Rank rank : Rank.values()) {
+            sum += rank.getPrice() * getEachRankCount(rank);
+        }
+        return ((double) sum / money.getMoney());
+    }
+
+    public Integer getEachRankCount(final Rank rank) {
+        return rankCount.get(rank);
+    }
+}

src/main/java/lotto/model/Lottos.java

@@ -0,0 +1,41 @@
+package lotto.model;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lotto.model.number.LottoNumber;
+import lotto.model.number.LottoNumbers;
+
+public class Lottos {
+
+    private final List<Lotto> lottos;
+
+    public Lottos(final List<Lotto> lottos) {
+        this.lottos = lottos;
+    }
+
+    public Map<Rank, Integer> calculateRanks(final LottoNumbers winningNumbers, final LottoNumber bonusNumber) {
+        Map<Rank, Integer> rankCount = initMap();
+        lottos.forEach(lotto -> {
+            Rank rank = lotto.calculateRank(winningNumbers, bonusNumber);
+            rankCount.put(rank, rankCount.get(rank) + 1);
+        });
+        return rankCount;
+    }
+
+    private Map<Rank, Integer> initMap() {
+        Map<Rank, Integer> map = new LinkedHashMap<>();
+        Arrays.stream(Rank.values()).forEach(rank -> map.put(rank, 0));
+        return map;
+    }
+
+    public List<Lotto> getLottos() {
+        return Collections.unmodifiableList(lottos);
+    }
+
+    public int size() {
+        return lottos.size();
+    }
+}

src/main/java/lotto/model/Money.java

@@ -0,0 +1,28 @@
+package lotto.model;
+
+public class Money {
+
+    private static final int PRICE_PER_LOTTO = 1000;
+    public static final String MONEY_ERROR_MESSAGE = "[ERROR] 유효한 구매 금액이 아닙니다.";
+
+    private final int money;
+
+    public Money(final int money) {
+        validateMoney(money);
+        this.money = money;
+    }
+
+    private void validateMoney(final int money) {
+        if (money < 0) {
+            throw new IllegalArgumentException(MONEY_ERROR_MESSAGE);
+        }
+    }
+
+    public int getMoney() {
+        return money;
+    }
+
+    public int lottoCount() {
+        return money / PRICE_PER_LOTTO;
+    }
+}

src/main/java/lotto/model/Rank.java

@@ -0,0 +1,42 @@
+package lotto.model;
+
+import java.util.Arrays;
+
+public enum Rank {
+    LOSER(0, false, 0),
+    FIFTH(3, false, 5_000),
+    FOURTH(4, false, 50_000),
+    THIRD(5, false, 1_500_000),
+    SECOND(5, true, 30_000_000),
+    FIRST(6, false, 2_000_000_000);
+
+    private final int count;
+    private final boolean winBonusNumber;
+    private final int price;
+
+    Rank(final int count, final boolean winBonusNumber, final int price) {
+        this.count = count;
+        this.winBonusNumber = winBonusNumber;
+        this.price = price;
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+    public boolean isWinBonusNumber() {
+        return winBonusNumber;
+    }
+
+    public int getPrice() {
+        return price;
+    }
+
+    public static Rank getRank(final int count, final boolean winBonusNumber) {
+        return Arrays.stream(Rank.values())
+                .filter(rank -> rank.count == count)
+                .filter(rank -> rank.winBonusNumber == winBonusNumber)
+                .findFirst()
+                .orElse(LOSER);
+    }
+}

src/main/java/lotto/model/WinningLotto.java

@@ -0,0 +1,29 @@
+package lotto.model;
+
+import java.util.Map;
+import lotto.model.number.LottoNumber;
+import lotto.model.number.LottoNumbers;
+
+public class WinningLotto {
+
+    private static final String DUPLICATED_NUMBER_ERROR_MESSAGE = "[ERROR] 보너스 번호가 중복되었습니다.";
+
+    private final LottoNumbers winningNumbers;
+    private final LottoNumber bonusNumber;
+
+    public WinningLotto(final LottoNumbers winningNumbers, final LottoNumber bonusNumber) {
+        this.winningNumbers = winningNumbers;
+        checkDuplicateNumber(bonusNumber);
+        this.bonusNumber = bonusNumber;
+    }
+
+    private void checkDuplicateNumber(LottoNumber bonusNumber) {
+        if (winningNumbers.containNumber(bonusNumber)) {
+            throw new IllegalArgumentException(DUPLICATED_NUMBER_ERROR_MESSAGE);
+        }
+    }
+
+    public Map<Rank, Integer> checkRank(Lottos lottos) {
+        return lottos.calculateRanks(winningNumbers, bonusNumber);
+    }
+}

src/main/java/lotto/model/generator/AutoLottoGenerator.java

@@ -0,0 +1,45 @@
+package lotto.model.generator;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import lotto.model.Lotto;
+import lotto.model.Lottos;
+import lotto.model.number.LottoNumber;
+import lotto.model.number.LottoNumbers;
+
+public class AutoLottoGenerator implements LottoGenerator {
+
+    private static final int LOTTO_START_INDEX = 0;
+
+    @Override
+    public Lottos generateLottos(int lottoCount, int minimumNumber, int maximumNumber, int lottoLength) {
+        List<Lotto> lottos = new ArrayList<>();
+        for (int i = 0; i < lottoCount; i++) {
+            LottoNumbers lottoNumbers = makeLottoNumbers(minimumNumber, maximumNumber, lottoLength);
+            lottos.add(makeLotto(lottoNumbers));
+        }
+        return new Lottos(lottos);
+    }
+
+    private LottoNumbers makeLottoNumbers(int minimumNumber, int maximumNumber, int lottoLength) {
+        List<Integer> numberCollection = makeNumberCollection(minimumNumber, maximumNumber);
+        Collections.shuffle(numberCollection);
+        return new LottoNumbers(numberCollection.subList(LOTTO_START_INDEX, lottoLength).stream()
+                .sorted()
+                .map(LottoNumber::new)
+                .collect(Collectors.toList()));
+    }
+
+    private List<Integer> makeNumberCollection(int minimumNumber, int maximumNumber) {
+        return IntStream.rangeClosed(minimumNumber, maximumNumber)
+                .boxed()
+                .collect(Collectors.toList());
+    }
+
+    private Lotto makeLotto(LottoNumbers lottoNumbers) {
+        return new Lotto(lottoNumbers);
+    }
+}