[스프링 화요일 1팀](박철) 미션 제출합니다.

build.gradle

@@ -8,7 +8,13 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.github.woowacourse-projects:mission-utils:1.0.0'
+    implementation 'com.github.kokodak:mission-utils:1.0.0'
+
+    implementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
+    implementation 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
+    implementation 'org.mockito:mockito-inline:3.12.4'
+    implementation 'org.assertj:assertj-core:3.21.0'
+    implementation 'org.junit.jupiter:junit-jupiter:5.8.1'
 }
 
 java {
@@ -19,4 +25,4 @@ java {
 
 test {
     useJUnitPlatform()
-}
+}

docs/README.md

@@ -0,0 +1,32 @@
+# 로또
+1. 입력
+   1. 금액 입력
+      - 정수인지 검증
+      - 0인지 검증
+      - 1000원 단위인지 검증
+   2. 당첨번호 입력
+      - 정수인지 검증
+      - 1~45사이 정수인지 검증
+      - 중복된 로또 번호가 존재하는지 검증
+      - 개수가 6개인지 검증
+   3. 보너스번호 입력
+      - 정수인지 검증
+      - 1~45사이 정수인지 검증
+      - 정규 당첨번호에 있는 수인지 검증
+2. 로또 생성
+   1. 금액//1000 만큼 로또 생성
+   2. 검증
+       - 1~45사이 정수인지 검증
+       - 중복된 로또 번호가 존재하는지 검증
+       - 개수가 6개인지 검증
+       - 오름차순인지 검증
+3. 로또 출력
+   1. 로또 수 출력
+   2. 로또 번호 출력
+4. 당첨번호와 로또 번호확인
+   1. 정규번호 6자리 와 당첨번호 비교, 5자리와 보너스 번호가 맞으면 2등
+   2. 당첨 수 계산
+5. 당첨결과 출력
+   1. 당첨 내역 출력
+   2. 수익률 출력
+

src/main/java/lotto/Application.java

@@ -1,7 +1,21 @@
 package lotto;
 
+import lotto.controller.LottoController;
+import lotto.view.InputView;
+import lotto.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
 public class Application {
     public static void main(String[] args) {
         // TODO: 프로그램 구현
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        LottoController lottoController = new LottoController(inputView,outputView);
+        lottoController.start();
+
     }
+
 }

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

@@ -0,0 +1,79 @@
+package lotto.controller;
+
+import lotto.domain.Lotto;
+import lotto.domain.Ranking;
+import lotto.domain.WinnigResult;
+import lotto.util.Constants;
+import lotto.util.ExceptionMessage;
+import lotto.util.LottoGenerator;
+import lotto.util.MoneyValidator;
+import lotto.view.InputView;
+import lotto.view.OutputView;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LottoController {
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public LottoController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void start(){
+        try {
+            int money=inputView.readMoney();
+            LottoGenerator lottoGenerator = new LottoGenerator();
+
+            List<Lotto> lottos = lottoGenerator.generate(money);
+            List<Integer> winningNumbers = inputView.readWinningNumbers();
+            int bonusNum = inputView.readBonusNumber(winningNumbers);
+            WinnigResult winnigResult = new WinnigResult(new Lotto(winningNumbers), bonusNum);
+            lottoResult(lottos, winnigResult, money / 1000);
+        }catch (IllegalArgumentException e){
+            System.out.println(e.getMessage());
+        }
+    }
+    private void lottoResult(List<Lotto> lottoList, WinnigResult winnigResult, int ticketNum){
+        Map<Ranking, Integer> result = setResult();
+        Ranking rank;
+
+        OutputView.printSuccessResult();
+        for (int i = 0; i < lottoList.size(); i++) {
+            rank = winnigResult.match(lottoList.get(i));
+
+            result.put(rank, result.get(rank) + 1);
+        }
+        printResult(result);
+        printEarningRate(result, ticketNum);
+    }
+
+    private void printResult(Map<Ranking, Integer> result) {
+        for (int i = Ranking.values().length - 1; i >= 0; i--) {
+            Ranking.values()[i].printMessage(result.get(Ranking.values()[i]));
+        }
+    }
+
+    private void printEarningRate(Map<Ranking, Integer> result, int lottoAmount) {
+        double EarningRate = 0;
+        for (Ranking rank : result.keySet()) {
+            EarningRate =
+                    EarningRate + ((double) (rank.getWinningAmount()) / (lottoAmount * Constants.LOTTO_PRICE) * (result.get(
+                            rank)) * (100));
+
+        }
+        OutputView.printRevenueRate(EarningRate);
+    }
+
+    private Map<Ranking, Integer> setResult() {
+        Map<Ranking, Integer> result = new LinkedHashMap<>();
+
+        for (Ranking rank : Ranking.values()) {
+            result.put(rank, 0);
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,64 @@
+package lotto.domain;
+
+import lotto.util.Constants;
+import lotto.util.ExceptionMessage;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static lotto.util.ExceptionMessage.INVALID_WINNING_NUMBER_DUPLICATE;
+import static lotto.util.ExceptionMessage.INVALID_WINNING_SIZE;
+
+public class Lotto {
+    private final List<Integer> numbers;
+
+    public Lotto(List<Integer> numbers) {
+        validate(numbers);
+        validateDuplicateNum(numbers);
+        validateNumRange(numbers);
+        this.numbers = numbers;
+        Collections.sort(numbers);
+    }
+
+
+    private void validate(List<Integer> numbers) {
+        if (numbers.size() != 6) {
+            throw new IllegalArgumentException(INVALID_WINNING_SIZE.getMessage());
+        }
+        Set<Integer> set = new HashSet<>(numbers);
+        if (set.size()!=6){
+            throw new IllegalArgumentException(INVALID_WINNING_NUMBER_DUPLICATE.getMessage());
+        }
+    }
+    private void validateDuplicateNum(List<Integer> numbers) {
+        Set<Integer> set = new HashSet<>(numbers);
+        if (set.size()!=6){
+            throw new IllegalArgumentException(INVALID_WINNING_NUMBER_DUPLICATE.getMessage());
+        }
+    }
+    private void validateNumRange(List<Integer> numbers) {
+
+        for (Integer number : numbers) {
+            if (number<=0 || number>45){
+                throw new IllegalArgumentException(ExceptionMessage.INVALID_LOTTO_NUMBER_RANGE.getMessage());
+            }
+        }
+    }
+
+    // TODO: 추가 기능 구현
+    //public void printResult
+    public int countMatch(List<Integer> winningNum){
+        return (int) numbers.stream()
+                .filter(winningNum::contains).count();
+    }
+    public boolean containNum(int num){
+        return numbers.contains(num);
+    }
+
+    public List<Integer> getNumbers() {
+        return numbers;
+    }
+
+}

src/main/java/lotto/domain/Ranking.java

@@ -0,0 +1,54 @@
+package lotto.domain;
+
+import lotto.view.OutputView;
+
+import java.util.Random;
+
+public enum Ranking {
+    FIRST(6, 2_000_000_000, "6개 일치 (2,000,000,000원) - "), // 1등
+    SECOND(5, 30_000_000, "5개 일치, 보너스 볼 일치 (30,000,000원) - "), // 2등
+    THIRD(5, 1_500_000, "5개 일치 (1,500,000원) - "), // 3등
+    FOURTH(4, 50_000, "4개 일치 (50,000원) - "), // 4등
+    FIFTH(3, 5_000, "3개 일치 (5,000원) - "), // 5등
+    MISS(0, 0, "");
+    Ranking(int countOfMatch, int winningAmount, String message) {
+        this.countOfMatch = countOfMatch;
+        this.winningAmount = winningAmount;
+        this.message = message;
+    }
+    private int countOfMatch;
+    private int winningAmount;
+    private String message;
+
+    private static final int WINNG_MIN_COUNT=3;
+    public static Ranking valueOf(int countOfMatch, boolean matchBonus){
+        if (countOfMatch<WINNG_MIN_COUNT){
+            return MISS;
+        }
+        if (SECOND.getCountOfMatch()==countOfMatch && matchBonus){
+            return SECOND;
+        }
+        for (Ranking rank : values()) {
+            if (rank.getCountOfMatch()==countOfMatch && rank!=SECOND){
+                return rank;
+            }
+        }
+        throw new IllegalArgumentException("[ERROR]");
+    }
+
+
+    public int getCountOfMatch() {
+        return countOfMatch;
+    }
+
+    public int getWinningAmount() {
+        return winningAmount;
+    }
+
+    public void printMessage(int count) {
+        if (this!=MISS){
+            OutputView.printSuccessMessage(message,count);
+        }
+
+    }
+}

src/main/java/lotto/domain/WinnigResult.java

@@ -0,0 +1,18 @@
+package lotto.domain;
+
+public class WinnigResult {
+    private final Lotto lotto;
+    private final int bonusball;
+
+    public WinnigResult(Lotto lotto, int bonusball) {
+        this.lotto = lotto;
+        this.bonusball = bonusball;
+    }
+
+    public Ranking match(Lotto playerNumber) {
+        int countOfMatch = playerNumber.countMatch(lotto.getNumbers());
+        boolean bonusCheck = playerNumber.containNum(bonusball);
+        return Ranking.valueOf(countOfMatch, bonusCheck);
+    }
+
+}

src/main/java/lotto/util/BonusNumValidator.java

@@ -0,0 +1,12 @@
+package lotto.util;
+
+import java.util.List;
+
+public class BonusNumValidator extends Validator{
+    @Override
+    public void validate(String input) throws IllegalStateException {
+        validateInt(input);
+        validateLottoNumberRange(input);
+    }
+
+}

src/main/java/lotto/util/Constants.java

@@ -0,0 +1,8 @@
+package lotto.util;
+
+public class Constants {
+    static final int NUM_COUNT=6;
+    static final int MAX_NUM=45;
+    static final int MIN_NUM=1;
+    public static final int LOTTO_PRICE=1000;
+}

src/main/java/lotto/util/ExceptionMessage.java

@@ -0,0 +1,24 @@
+package lotto.util;
+
+import static lotto.util.Constants.LOTTO_PRICE;
+
+public enum ExceptionMessage {
+    NOT_INT("정수를 입력해주세요"),
+    INVALID_LOTTO_NUMBER_RANGE("로또 번호는 1부터 45 사이의 숫자여야 합니다."),
+    INVALID_MONEY_UNIT(String.format("%d원 단위로 구매해야합니다.", LOTTO_PRICE)),
+    ZERO_EXCEPTION("0보다 큰 금액을 입력해주세요"),
+    INVALID_WINNING_SIZE("6개의 번호를 입력해주세요."),
+    INVALID_WINNING_NUMBER_DUPLICATE("중복되지 않은 6개의 번호를 입력해주세요."),
+    INVALID_BONUS_NUM("보너스가 번호가 정규번호와 중복되었습니다.");
+
+    public static final String BASE_MESSAGE="[ERROR] %s";
+    private final String message;
+
+    ExceptionMessage(String message){
+        this.message= String.format(BASE_MESSAGE, message);
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}

src/main/java/lotto/util/LottoGenerator.java

@@ -0,0 +1,26 @@
+package lotto.util;
+
+import lotto.domain.Lotto;
+import lotto.view.OutputView;
+import org.kokodak.Randoms;
+
+import java.util.*;
+
+import static lotto.util.Constants.*;
+
+public class LottoGenerator {
+    public List<Lotto> generate(int money){
+        int ticketNum=money/1000;
+
+        OutputView.printTicketCount(ticketNum);
+        List<Lotto> lottos=new ArrayList<>();
+        for (int i=0; ticketNum>i; i++){
+            List<Integer> lottoNum= new ArrayList<>(Randoms.pickUniqueNumbersInRange(MIN_NUM,MAX_NUM,NUM_COUNT));
+            Lotto lotto = new Lotto(lottoNum);
+            lottos.add(lotto);
+            System.out.println(lotto.getNumbers());
+
+        }
+        return lottos;
+    }
+}