로또 1단계 미션 제출

README.md

@@ -1,5 +1,47 @@
 # 🚀 로또 1단계 - 자동
 
+##  📋기능 구현 목록
+* **UI 로직**
+  - [x] 구매 금액 입력
+  - [x] 당첨 번호 입력(보너스 볼)
+  - [x] 로또 번호 출력
+  - [x] 당첨 금액 출력
+  - [x] 수익률 출력
+
+* **비지니스 로직**
+  - [x] 로또 번호는 45까지 허용
+  - [x] 로또 번호는 6개
+  - [x] 보너스 번호는 1개
+  - [x] 로또 한 장 당 가격은 1000원
+  - [x] 로또 티켓 갯수 계산
+  - [x] 로또 번호 생성
+  - [x] 일치 여부 확인
+  - [x] 당첨 금액 계산
+  - [x] 수익률 계산
+
+
+## 🎯예외 사항 목록
+* **구매 금액 입력**
+  - [x] 1000원 이하일 경우
+  - [x] 1000원 단위가 아닐 경우
+
+* **로또 번호 입력**
+  - [x] 46 이상의 입력이 있을 경우
+  - [x] 중복된 수가 입력될 경우
+  - [x] 6개 이상 입력 될 경우
+  - [x] 보너스 볼이 1개 이상 입력 될 경우
+
+
+## 클래스 및 매소드
+- Application
+- Lotto
+- Lottos
+- WinningNumber
+- Printer
+- Receiver
+
+
+
 ## 기능 요구사항
 - 로또 구입 금액을 입력하면 구입 금액에 해당하는 로또를 발급해야 한다.
 - 로또 1장의 가격은 1000원이다.

build.gradle

@@ -2,7 +2,7 @@ apply plugin: 'java'
 apply plugin: 'eclipse'
 
 version = '1.0.0'
-sourceCompatibility = 1.8
+sourceCompatibility = 14
 
 repositories {
     mavenCentral()

src/main/java/lotto/LottoApplication.java

@@ -0,0 +1,90 @@
+  package lotto;
+
+import lotto.domain.Statistics;
+import lotto.domain.factory.Issuer;
+import lotto.domain.lotto.LottoTickets;
+import lotto.domain.lotto.WinningNumber;
+import lotto.domain.result.GameResults;
+import lotto.ui.Printer;
+import lotto.ui.Receiver;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class LottoApplication {
+    private static final String LOTTO_NUMBER_INPUT_DELIMITER = ", ";
+    private static final int LOTTO_TICKET_PRICE = 1000;
+    private static final String LOTTO_TICKET_PRICE_RANGE_EXCEPTION_MESSAGE =
+            "수동 구매 티켓의 갯수가 구입 금액을 초과했습니다.";
+
+    private final Printer printer;
+    private final Receiver receiver;
+
+    public LottoApplication(Printer printer, Receiver receiver) {
+        this.printer = printer;
+        this.receiver = receiver;
+    }
+
+    public static void main(String[] args) {
+        LottoApplication app = new LottoApplication(new Printer(), new Receiver(System.in));
+        app.run();
+    }
+
+    public void run() {
+        int purchaseAmount = receivePurchaseAmount();
+        int manualTicketCount = receiveManualTicketCount(purchaseAmount);
+        LottoTickets lottoTickets = Issuer.issueManualLottoTickets(manualTicketCount, receiveManualTicketNumber(manualTicketCount));
+        lottoTickets.addTickets(Issuer.issueLottoTickets(purchaseAmount, manualTicketCount));
+        printer.printIssuedTickets(lottoTickets, manualTicketCount);
+
+        WinningNumber winningNumber = new WinningNumber(receiveWinningNumber(), receiveBonusNumber());
+        GameResults gameResults = lottoTickets.matchNumbers(winningNumber);
+        Statistics statistics = new Statistics(gameResults, purchaseAmount);
+        printer.printStatistics(statistics);
+    }
+
+    private int receivePurchaseAmount() {
+        printer.requestPurchaseAmount();
+        String purchaseAmount = receiver.receiveLine();
+        return Integer.parseInt(purchaseAmount);
+    }
+
+    private int receiveManualTicketCount(int purchaseAmount) {
+        printer.requestManualTicketCount();
+        int manualTicketCount = Integer.parseInt(receiver.receiveLine());
+        if(manualTicketCount > purchaseAmount/LOTTO_TICKET_PRICE){
+            throw new IllegalArgumentException(LOTTO_TICKET_PRICE_RANGE_EXCEPTION_MESSAGE);
+        }
+        return manualTicketCount;
+    }
+
+    private List<List<Integer>> receiveManualTicketNumber(int manualTicketCount) {
+        printer.requestManualTicketNumber();
+        List<List<Integer>> manualTickets = new ArrayList<>();
+        for(int count = 0; count <manualTicketCount; count++) {
+            String manualNumber = receiver.receiveLine();
+
+             manualTickets.add(Arrays.stream(manualNumber.split(LOTTO_NUMBER_INPUT_DELIMITER))
+                    .map(Integer::valueOf)
+                    .collect(Collectors.toList()));
+        }
+        return manualTickets;
+    }
+
+    private List<Integer> receiveWinningNumber() {
+        printer.requestWinningNumber();
+        String winningNumber = receiver.receiveLine();
+
+        return Arrays.stream(winningNumber.split(LOTTO_NUMBER_INPUT_DELIMITER))
+                .map(Integer::valueOf)
+                .collect(Collectors.toList());
+    }
+
+    private int receiveBonusNumber() {
+        printer.requestBonusNumber();
+        String bonusNumber = receiver.receiveLine();
+        return Integer.parseInt(bonusNumber);
+    }
+}

src/main/java/lotto/domain/MatchCount.java

@@ -0,0 +1,27 @@
+package lotto.domain;
+public class MatchCount {
+    private final int matchCount;
+    private final boolean isBonusMatch;
+    public MatchCount(int matchCount, boolean isBonusMatch) {
+        this.matchCount = matchCount;
+        this.isBonusMatch = isBonusMatch;
+    }
+    public boolean isUnderThree() {
+        return matchCount < 3;
+    }
+    public boolean isMatchThree() {
+        return matchCount == 3;
+    }
+    public boolean isMatchFour() {
+        return matchCount == 4;
+    }
+    public boolean isMatchFiveWithoutBonus() {
+        return matchCount == 5 && !isBonusMatch;
+    }
+    public boolean isMatchFiveWithBonus() {
+        return matchCount == 5 && isBonusMatch;
+    }
+    public boolean isAllMatch() {
+        return matchCount == 6;
+    }
+}

src/main/java/lotto/domain/Statistics.java

@@ -0,0 +1,35 @@
+package lotto.domain;
+
+import lotto.domain.dto.WinningResult;
+import lotto.domain.result.GameResult;
+import lotto.domain.result.GameResults;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Statistics {
+    private static final int IS_EQUAL_RATE = 1;
+
+    private final GameResults gameResults;
+    private final int purchaseAmount;
+
+    public Statistics(GameResults gameResults, int purchaseAmount) {
+        this.gameResults = gameResults;
+        this.purchaseAmount = purchaseAmount;
+    }
+
+    public List<WinningResult> winningResults() {
+        return GameResult.valuesWithoutUnderThreeMatched()
+                .stream()
+                .map(gameResult -> new WinningResult(gameResults.count(gameResult), gameResult))
+                .collect(Collectors.toList());
+    }
+
+    public double calculateEarningRate() {
+        return gameResults.calculatePrize() / purchaseAmount;
+    }
+
+    public boolean isProfit(double earningRate) {
+        return earningRate > IS_EQUAL_RATE;
+    }
+}

src/main/java/lotto/domain/dto/WinningResult.java

@@ -0,0 +1,18 @@
+package lotto.domain.dto;
+
+import lotto.domain.result.GameResult;
+
+public class WinningResult {
+    private final int numberOfWinners;
+    private final GameResult gameResult;
+    public WinningResult(int numberOfWinners, GameResult gameResult) {
+        this.numberOfWinners = numberOfWinners;
+        this.gameResult = gameResult;
+    }
+    public int getNumberOfWinners() {
+        return numberOfWinners;
+    }
+    public GameResult getGameResult() {
+        return gameResult;
+    }
+}

src/main/java/lotto/domain/factory/Issuer.java

@@ -0,0 +1,35 @@
+package lotto.domain.factory;
+import lotto.domain.lotto.LottoTicket;
+import lotto.domain.lotto.LottoTickets;
+
+import java.util.ArrayList;
+import java.util.List;
+public class Issuer {
+    private static final int TICKET_PRICE = 1000;
+    private static final int MINIMUM_NUMBER_OF_TICKETS = 1;
+    private static final String MONEY_AMOUNT_EXCEPTION_MESSAGE = "금액은 " + TICKET_PRICE + "원 이상으로 입력해주세요.";
+
+    public static LottoTickets issueManualLottoTickets(int manualTicketCount, List<List<Integer>> manualLottoTicketNumbers){
+        validate(manualTicketCount);
+        List<LottoTicket> manualLottoTickets = new ArrayList<>();
+        for(int i = 0; i <manualTicketCount; i++) {
+            manualLottoTickets.add(new LottoTicket(manualLottoTicketNumbers.get(i)));
+        }
+        return new LottoTickets(manualLottoTickets);
+    }
+
+    public static LottoTickets issueLottoTickets(int money, int manualTicketCount) {
+        int numberOfTickets = (money / TICKET_PRICE)-manualTicketCount;
+        validate(numberOfTickets);
+        List<LottoTicket> lottoTickets = new ArrayList<>();
+        for (int i = 0; i < numberOfTickets; i++) {
+            lottoTickets.add(new LottoTicket());
+        }
+        return new LottoTickets(lottoTickets);
+    }
+    private static void validate(int numberOfTickets) {
+        if (numberOfTickets < MINIMUM_NUMBER_OF_TICKETS) {
+            throw new IllegalArgumentException(MONEY_AMOUNT_EXCEPTION_MESSAGE);
+        }
+    }
+}

src/main/java/lotto/domain/lotto/LottoNumber.java

@@ -0,0 +1,52 @@
+package lotto.domain.lotto;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+public class LottoNumber {
+    private static final int LOTTO_NUMBER_LOWER_BOUND = 1;
+    private static final int LOTTO_NUMBER_UPPER_BOUND = 45;
+    private static final String LOTTO_NUMBER_RANGE_EXCEPTION_MESSAGE =
+            "로또 번호는 " + LOTTO_NUMBER_LOWER_BOUND + " 이상, " + LOTTO_NUMBER_UPPER_BOUND + " 이하여야 합니다.";
+    private final int lottoNumber;
+    public LottoNumber(int lottoNumber) {
+        validate(lottoNumber);
+        this.lottoNumber = lottoNumber;
+    }
+    private void validate(int lottoNumber) {
+        if (!isInRange(lottoNumber)) {
+            throw new IllegalArgumentException(LOTTO_NUMBER_RANGE_EXCEPTION_MESSAGE);
+        }
+    }
+    private boolean isInRange(int lottoNumber) {
+        return lottoNumber >= LOTTO_NUMBER_LOWER_BOUND && lottoNumber <= LOTTO_NUMBER_UPPER_BOUND;
+    }
+    public static List<LottoNumber> range() {
+        return IntStream.range(LOTTO_NUMBER_LOWER_BOUND, LOTTO_NUMBER_UPPER_BOUND + 1)
+                .boxed()
+                .map(LottoNumber::new)
+                .collect(Collectors.toList());
+    }
+    public static List<LottoNumber> setManualNumber(List<Integer> manualNumber){
+        List<LottoNumber> lottoNumberManualNumber = new ArrayList<>();
+        for (Integer integer : manualNumber) {
+            lottoNumberManualNumber.add(new LottoNumber(integer));
+        }
+        return lottoNumberManualNumber;
+    }
+    public int getLottoNumber() {
+        return lottoNumber;
+    }
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        LottoNumber that = (LottoNumber) o;
+        return lottoNumber == that.lottoNumber;
+    }
+    @Override
+    public int hashCode() {
+        return Objects.hash(lottoNumber);
+    }
+}

src/main/java/lotto/domain/lotto/LottoTicket.java

@@ -0,0 +1,35 @@
+package lotto.domain.lotto;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+public class LottoTicket {
+    private static final int NUMBER_OF_LOTTO_NUMBERS = 6;
+    private List<LottoNumber> lottoNumbers;
+
+    public LottoTicket() {
+        List<LottoNumber> lottoNumbers = LottoNumber.range();
+        lottoNumbers = generateLottoNumbers(lottoNumbers);
+        this.lottoNumbers = new ArrayList<>(lottoNumbers);
+    }
+    public LottoTicket(List<Integer> manualLottoNumbers){
+        List<LottoNumber> lottoNumbers = LottoNumber.setManualNumber(manualLottoNumbers);
+        this.lottoNumbers = new ArrayList<>(lottoNumbers);
+    }
+
+    private List<LottoNumber> generateLottoNumbers(List<LottoNumber> lottoNumbers) {
+        Collections.shuffle(lottoNumbers);
+        lottoNumbers = lottoNumbers.stream()
+                .limit(NUMBER_OF_LOTTO_NUMBERS)
+                .sorted(Comparator.comparing(LottoNumber::getLottoNumber))
+                .collect(Collectors.toList());
+        return lottoNumbers;
+    }
+    public boolean contains(LottoNumber lottoNumber) {
+        return lottoNumbers.contains(lottoNumber);
+    }
+    public List<LottoNumber> getLottoNumbers() {
+        return lottoNumbers;
+    }
+}

src/main/java/lotto/domain/lotto/LottoTickets.java

@@ -0,0 +1,26 @@
+package lotto.domain.lotto;
+import lotto.domain.result.GameResult;
+import lotto.domain.result.GameResults;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+public class LottoTickets {
+    private final List<LottoTicket> lottoTickets;
+    public LottoTickets(List<LottoTicket> lottoTickets) {
+        this.lottoTickets = new ArrayList<>(lottoTickets);
+    }
+    public void addTickets(LottoTickets lottoTickets){
+        this.lottoTickets.addAll(lottoTickets.getLottoTickets());
+    }
+    public GameResults matchNumbers(WinningNumber winningNumber) {
+        List<GameResult> results = lottoTickets.stream()
+                .map(winningNumber::matchNumbers)
+                .map(GameResult::evaluate)
+                .collect(Collectors.toList());
+        return new GameResults(results);
+    }
+    public List<LottoTicket> getLottoTickets() {
+        return lottoTickets;
+    }
+}