[SCG] 손희창 로또 1-2단계 미션 제출합니다.

README.md

@@ -0,0 +1,121 @@
+# 1단계 요구사항 정리
+
+---
+
+## 기능 요구사항
+
+- [x] 로또 구입 금액을 입력하면 구입 금액에 해당하는 로또를 발급해야 한다.
+- [x] 로또 1장의 가격은 1000원이다.
+- [x] 로또 당첨 번호를 받아 일치한 번호 수에 따라 당첨 결과를 보여준다.
+
+## 새로운 프로그래밍 요구사항
+
+- [x] 배열 대신 컬렉션을 사용한다.
+- [x] 줄여 쓰지 않는다(축약 금지).
+- [x] 함수(또는 메서드)의 길이가 10라인을 넘어가지 않도록 구현한다.
+- [x] 함수(또는 메서드)가 한 가지 일만 하도록 최대한 작게 만들어라.
+- [x] 모든 원시 값과 문자열을 포장한다.
+- [x] 일급 컬렉션을 쓴다.
+
+## 기존 프로그래밍 요구사항
+
+자바 코드 컨벤션을 지키면서 프로그래밍한다.
+기본적으로 Java Style Guide을 원칙으로 한다.
+indent(인덴트, 들여쓰기) depth를 2를 넘지 않도록 구현한다. 1까지만 허용한다.
+예를 들어 while문 안에 if문이 있으면 들여쓰기는 2이다.
+힌트: indent(인덴트, 들여쓰기) depth를 줄이는 좋은 방법은 함수(또는 메서드)를 분리하면 된다.
+3항 연산자를 쓰지 않는다.
+else 예약어를 쓰지 않는다.
+else 예약어를 쓰지 말라고 하니 switch/case로 구현하는 경우가 있는데 switch/case도 허용하지 않는다.
+
+---
+
+## 사용할 클래스의 종류 및 특징 정리
+
+### 도메인
+
+#### Money
+
+1. 입력금액을 저장한다.
+2. 로또 횟수정보를 환산하여 저장한다.
+3. 입력과정에서 예외처리를 수행한다.
+
+#### RandomLottoGenerator
+
+원소가 6개인 중복 없는 랜덤 ArrayList를 생성하여 반환한다.
+
+#### Lotto
+
+리스트 형태의 로또 일급 클래스
+
+#### LottoCalculator
+
+겹침 횟수를 환산하고 Rank와 매핑하고 전체 상금액을 구하여 수익률을 구한다.
+
+#### LottoNumber
+
+자료형 형태의 로또 숫자 클래스
+
+#### Lottos
+
+리스트 형태의 로또 일급 클래스를 담는 일급 클래스
+
+#### Rank(Enum)
+
+겹침 횟수와 해당 금액을 저장한다.
+겹침 횟수를 받으면 겹침 횟수와 해당 금액을 함께 반환한다.
+
+### 뷰
+
+#### InputView
+
+금액을 입력받는다.
+이후 입력받은 금액을 return함.
+
+### ResultView
+
+횟수를 출력하고,
+이 횟수만큼 반복하여 ArrayList를 출력한다.
+통계와 수익률을 출력한다.
+
+### 컨트롤러
+
+#### Application
+
+도메인과 뷰를 실행한다.
+
+# 예외 처리
+
+- 구입금액에서 빈값을 받았을 때
+- 구입금액이 숫자가 아닐 때
+- 구입금액이 1000원보다 작을 때
+- 구입금액이 1000원 단위가 아닐 때
+- 지난 주 당첨번호가 적절한 형식이 아닐 때
+- 지난 주 당첨번호들 중 중복된 번호가 있을 때
+- 로또 번호가 1~45 범위가 아닐때
+- 지난 주 당첨번호 개수가 6개가 아닐 때
+
+# 테스트 케이스
+
+```text
+구입금액을 입력해 주세요.
+5000
+
+5개를 구매했습니다.
+[3, 14, 16, 18, 22, 40]
+[4, 18, 19, 30, 31, 36]
+[7, 9, 20, 22, 30, 41]
+[6, 18, 20, 28, 35, 39]
+[5, 13, 14, 37, 44, 45]
+
+지난 주 당첨번호를 입력해 주세요.
+3, 14, 20, 22, 30, 40
+
+당첨 통계
+---------
+6개 일치 (2000000000)- 0개
+5개 일치 (1500000)- 0개
+4개 일치 (50000)- 1개
+3개 일치 (5000)- 1개
+총 수익률은 11.00입니다.(기준이 1이기 때문에 결과적으로 이득이라 더 뽑아도 된다는 의미임)
+```

src/main/java/Application.java

@@ -0,0 +1,79 @@
+import domain.Lotto;
+import domain.LottoCalculator;
+import domain.LottoMachine;
+import domain.Lottos;
+import domain.Money;
+import domain.RandomLottoGenerator;
+import domain.Rank;
+import java.util.ArrayList;
+import java.util.List;
+import view.InputView;
+import view.ResultView;
+
+public class Application {
+    private final InputView inputView = new InputView();
+    private final ResultView resultView = new ResultView();
+    private final RandomLottoGenerator random = new RandomLottoGenerator();
+
+    public void run() {
+        final int amount = inputView.getMoney(); //돈 받기
+        Money money = new Money(amount); // 돈 저장
+        final int number = LottoMachine.calculateTicketCount(money); // 로또 뽑는 횟수
+        resultView.printPurchaseCount(number);
+        Lottos lottos = purchaseLotto(number);
+        Lotto winnerNumbers = inputView.getWinnerNumbers(); //당첨번호 로또 입력
+        LottoCalculator calculator = calculatorResult(lottos, winnerNumbers); //당첨 결과 계산
+        printStatistics(calculator, money);//최종 통계 및 수익률 출력
+    }
+
+
+    public Lottos purchaseLotto(int count) {
+        List<Lotto> purchased = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            Lotto lotto = random.generate();
+            printLotto(lotto);
+            purchased.add(lotto);
+        }
+        return new Lottos(purchased);
+    }
+
+    public void printLotto(Lotto lotto) {
+        resultView.printLottoNumbers(lotto);
+    }
+
+    private LottoCalculator calculatorResult(Lottos lottos, Lotto winnerNumbers) {
+        LottoCalculator calculator = new LottoCalculator();
+        for (Lotto lotto : lottos.getLottos()) {
+            int matchCount = lotto.getMatchNumbers(winnerNumbers);
+            Rank rank = Rank.MISS.valueOf(matchCount);
+            calculator.valueAdd(rank);
+        }
+        return calculator;
+    }
+
+    public void printStatistics(LottoCalculator calculator, Money money) {
+        resultView.printStatics();
+        for (Rank rank : Rank.values()) {
+            AddWinningMoney(calculator, rank);
+        }
+        double yield = calculator.calculateYield(money);
+        resultView.printYield(yield, yield >= 1.0);
+    }
+
+    public void AddWinningMoney(LottoCalculator calculator, Rank rank) {
+        if (rank != Rank.MISS) {
+            resultView.printWinningStatics(
+                    rank.getMatchnumbers(),
+                    rank.getPrizemoney(),
+                    calculator.getResult().get(rank)
+            );
+        }
+    }
+
+    public static void main(String[] args) {
+        Application lotto = new Application();
+        lotto.run();
+
+    }
+
+}

src/main/java/domain/Lotto.java

@@ -0,0 +1,48 @@
+package domain;
+
+import java.util.List;
+
+public class Lotto {
+    public static final int LOTTO_NUMBER_COUNT = 6;
+    private final List<LottoNumber> lottoNumbers;
+
+    public Lotto(List<LottoNumber> lottoNumbers) {
+        validate(lottoNumbers);
+        this.lottoNumbers = lottoNumbers;
+    }
+
+    private void validate(List<LottoNumber> numbers) {
+        validateSize(numbers);
+        validateDuplicate(numbers);
+    }
+
+    private void validateSize(List<LottoNumber> numbers) {
+        if (numbers.size() != LOTTO_NUMBER_COUNT) {
+            throw new IllegalArgumentException("로또 숫자 개수가 " + LOTTO_NUMBER_COUNT + "개여야 합니다.");
+        }
+    }
+
+    private void validateDuplicate(List<LottoNumber> numbers) {
+        long distinctCount = numbers.stream()
+                .distinct()
+                .count();
+
+        if (distinctCount != numbers.size()) {
+            throw new IllegalArgumentException("중복된 로또 숫자가 존재합니다.");
+        }
+    }
+
+    public List<LottoNumber> getLotto() {
+        return lottoNumbers;
+    }
+
+    public int getMatchNumbers(Lotto winnerNumbers) {
+        return (int) lottoNumbers.stream()
+                .filter(winnerNumbers::contains)
+                .count();
+    }
+
+    public boolean contains(LottoNumber number) {
+        return lottoNumbers.contains(number);
+    }
+}

src/main/java/domain/LottoCalculator.java

@@ -0,0 +1,31 @@
+package domain;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class LottoCalculator {
+    private final Map<Rank, Integer> result;
+
+    public LottoCalculator() {
+        result = new LinkedHashMap<>();
+        for (Rank rank : Rank.values()) {
+            result.put(rank, 0);
+        }
+    }
+
+    public void valueAdd(Rank rank) {
+        result.put(rank, result.get(rank) + 1);
+    }
+
+    public double calculateYield(Money money) {
+        double totalPrize = 0;
+        for (Rank rank : Rank.values()) {
+            totalPrize += rank.getPrizemoney() * result.get(rank);
+        }
+        return totalPrize / money.getAmount();
+    }
+
+    public Map<Rank, Integer> getResult() {
+        return result;
+    }
+}

src/main/java/domain/LottoMachine.java

@@ -0,0 +1,17 @@
+package domain;
+
+public class LottoMachine {
+    private static final int LOTTO_PRICE = 1000;
+
+    public static int calculateTicketCount(Money money) {
+        int amount = money.getAmount();
+        validateLottoUnit(amount);
+        return amount / LOTTO_PRICE;
+    }
+
+    private static void validateLottoUnit(int amount) {
+        if (amount < LOTTO_PRICE || amount % LOTTO_PRICE != 0) {
+            throw new IllegalArgumentException("로또는 1000원 단위로만 구매 가능합니다.");
+        }
+    }
+}

src/main/java/domain/LottoNumber.java

@@ -0,0 +1,44 @@
+package domain;
+
+public class LottoNumber {
+    public static final int MAX_NUMBER = 45;
+    public static final int MIN_NUMBER = 1;
+    private final int number;
+
+    public LottoNumber(int number) {
+        validatorNumber(number);
+        this.number = number;
+    }
+
+    public void validatorNumber(int number) {
+        if (number < MIN_NUMBER || number > MAX_NUMBER) {
+            throw new IllegalArgumentException("로또 번호가 범위를 벗어났습니다.");
+        }
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(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 java.util.Objects.hash(number);
+    }
+}

src/main/java/domain/Lottos.java

@@ -0,0 +1,15 @@
+package domain;
+
+import java.util.List;
+
+public class Lottos {
+    private final List<Lotto> lottos;
+
+    public Lottos(List<Lotto> lottos) {
+        this.lottos = lottos;
+    }
+
+    public List<Lotto> getLottos(){
+        return lottos;
+    }
+}

src/main/java/domain/Money.java

@@ -0,0 +1,20 @@
+package domain;
+
+public class Money {
+    private final int amount;
+
+    public Money(int amount) {
+        validatePositive(amount);
+        this.amount = amount;
+    }
+
+    private void validatePositive(int amount) {
+        if (amount < 0) {
+            throw new IllegalArgumentException("금액은 음수일 수 없습니다.");
+        }
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+}