Step2: 로또(자동)

README.md

@@ -1,3 +1,48 @@
+# STEP 2: 로또(자동)
+
+## 기능 요구사항
+* 로또 구입 금액을 입력하면 구입 금액에 해당하는 로또를 발급해야 한다.
+* 로또 1장의 가격은 1000원이다.
+
+## 진행 목록
+- [x] 로또가 6개의 랜덤 숫자를 가지도록 한다.
+- [x] 로또 생성중에 겹치는 숫자가 있거나, 숫자가 6개가 아닌 경우 exception을 발생시킨다.
+- [x] 1개의 당첨숫자를 입력받아 가지도록 한다.
+- [x] 입력받은 당첨숫자와 n개의 숫자가 일치하는 로또의 수를 확인한다.
+- [x] 사용자에게 입력받은 금액으로 로또를 발급한다.
+-[x] 로또의 수익률을 계산한다.
+-[x] 로또의 결과를 출력한다.
+
+## 힌트
+ - 로또 자동 생성은 Collections.shuffle() 메소드 활용한다.
+ - Collections.sort() 메소드를 활용해 정렬 가능하다.
+ - ArrayList의 contains() 메소드를 활용하면 어떤 값이 존재하는지 유무를 판단할 수 있다.
+
+## 프로그래밍 요구사항
+ - 모든 기능을 TDD로 구현해 단위 테스트가 존재해야 한다. 단, UI(System.out, System.in) 로직은 제외
+ - 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 구분한다.
+ - UI 로직을 InputView, ResultView와 같은 클래스를 추가해 분리한다.
+ - indent(인덴트, 들여쓰기) depth를 2를 넘지 않도록 구현한다. 1까지만 허용한다.
+ - 예를 들어 while문 안에 if문이 있으면 들여쓰기는 2이다.
+ - 힌트: indent(인덴트, 들여쓰기) depth를 줄이는 좋은 방법은 함수(또는 메소드)를 분리하면 된다.
+ - 함수(또는 메소드)의 길이가 15라인을 넘어가지 않도록 구현한다.
+ - 함수(또는 메소드)가 한 가지 일만 잘 하도록 구현한다.
+ - 모든 로직에 단위 테스트를 구현한다. 단, UI(System.out, System.in) 로직은 제외
+ - 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 구분한다.
+ - UI 로직을 InputView, ResultView와 같은 클래스를 추가해 분리한다.
+ - 자바 코드 컨벤션을 지키면서 프로그래밍한다.
+   - 참고문서: https://google.github.io/styleguide/javaguide.html 또는 https://myeonguni.tistory.com/1596
+ - else 예약어를 쓰지 않는다.
+   - 힌트: if 조건절에서 값을 return하는 방식으로 구현하면 else를 사용하지 않아도 된다.
+   - else를 쓰지 말라고 하니 switch/case로 구현하는 경우가 있는데 switch/case도 허용하지 않는다.
+
+## 기능 목록 및 commit 로그 요구사항
+ - 기능을 구현하기 전에 README.md 파일에 구현할 기능 목록을 정리해 추가한다.
+ - git의 commit 단위는 앞 단계에서 README.md 파일에 정리한 기능 목록 단위로 추가한다.
+
+-----------------------------------------------
+# STEP 1: 문자열 사칙 연산 계산기
+
 # 문자열 사칙 연산 계산기 구현
 | 이번 미션의 핵심은 내가 구현하는 코드에 단위 테스트를 추가하는 경험을 하는 것이다.
 | 모든 예외 상황을 처리하기 위해 너무 복잡하게 접근하지 않아도 된다.
@@ -13,11 +58,11 @@
 -[x] 사용자에게 입력을 받을 수 있는 input view를 구현한다.
 
 ## 기능 요구사항
-사용자가 입력한 문자열 값에 따라 사칙연산을 수행할 수 있는 계산기를 구현해야 한다.
-입력 문자열의 숫자와 사칙 연산 사이에는 반드시 빈 공백 문자열이 있다고 가정한다.
-나눗셈의 경우 결과 값을 정수로 떨어지는 값으로 한정한다.
-문자열 계산기는 사칙연산의 계산 우선순위가 아닌 입력 값에 따라 계산 순서가 결정된다. 즉, 수학에서는 곱셈, 나눗셈이 덧셈, 뺄셈 보다 먼저 계산해야 하지만 이를 무시한다.
-예를 들어 2 + 3 * 4 / 2와 같은 문자열을 입력할 경우 2 + 3 * 4 / 2 실행 결과인 10을 출력해야 한다.
+* 사용자가 입력한 문자열 값에 따라 사칙연산을 수행할 수 있는 계산기를 구현해야 한다.
+* 입력 문자열의 숫자와 사칙 연산 사이에는 반드시 빈 공백 문자열이 있다고 가정한다.
+* 나눗셈의 경우 결과 값을 정수로 떨어지는 값으로 한정한다.
+* 문자열 계산기는 사칙연산의 계산 우선순위가 아닌 입력 값에 따라 계산 순서가 결정된다. 즉, 수학에서는 곱셈, 나눗셈이 덧셈, 뺄셈 보다 먼저 계산해야 하지만 이를 무시한다.
+* 예를 들어 2 + 3 * 4 / 2와 같은 문자열을 입력할 경우 2 + 3 * 4 / 2 실행 결과인 10을 출력해야 한다.
 
 ## 프로그래밍 요구사항
  - indent(들여쓰기) depth를 2단계에서 1단계로 줄여라.

src/main/java/Main.java

@@ -0,0 +1,20 @@
+import lotto.domain.Lotto;
+import lotto.domain.LottoChecker;
+import lotto.view.LottoInputView;
+import lotto.view.LottoOutputView;
+
+import java.util.List;
+
+public class Main {
+    public static void main(String[] args) {
+
+        LottoInputView.initiateScanner();
+        List<Lotto> purchasedLottos = LottoInputView.createPurchasedLottos(LottoInputView.scanAmount());
+
+        LottoOutputView.printPurchaseInfo(purchasedLottos);
+
+        Lotto winLotto = LottoInputView.createLottoWithScan(LottoInputView.scanWinNumbers());
+
+        LottoOutputView.printResultInfo(new LottoChecker(purchasedLottos, winLotto));
+    }
+}

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

@@ -0,0 +1,38 @@
+package lotto.domain;
+
+import java.util.Collections;
+import java.util.List;
+
+public class Lotto {
+    private final List<Integer> numbers;
+
+    public Lotto(List<Integer> numbers) {
+        numberEmptyCheck(numbers);
+        duplicateNumberCheck(numbers);
+
+        Collections.sort(numbers);
+        this.numbers = numbers;
+    }
+
+    public Integer getLottoSize() {
+        return this.numbers.size();
+    }
+
+    private void duplicateNumberCheck(List<Integer> numbers) {
+        if (numbers.stream().distinct().count() < 6)
+            throw new IllegalArgumentException("중복된 숫자가 있습니다.");
+    }
+
+    private void numberEmptyCheck(List<Integer> numbers) {
+        if (numbers == null || numbers.isEmpty())
+            throw new IllegalArgumentException("로또 번호가 없습니다.");
+    }
+
+    public Boolean containsNumbers(List<Integer> numbers) {
+        return this.numbers.containsAll(numbers);
+    }
+
+    public Integer getNumberByIndex(Integer index) {
+        return this.numbers.get(index);
+    }
+}

src/main/java/lotto/domain/LottoChecker.java

@@ -0,0 +1,58 @@
+package lotto.domain;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class LottoChecker {
+
+    private final int[] matchCounts;
+    private final List<Lotto> purchasedLottos;
+    private final Lotto winNumberLotto;
+
+    public LottoChecker(List<Lotto> purchasedLottos, Lotto winNumberLotto) {
+        winnerLottoEmptyCheck(winNumberLotto);
+
+        this.purchasedLottos = purchasedLottos != null ? purchasedLottos : new ArrayList<>();
+        this.winNumberLotto = winNumberLotto;
+        int[] matchCounts = new int[7];
+
+        for (Lotto lotto : this.purchasedLottos) {
+            matchCounts[countMatch(lotto)]++;
+        }
+
+        this.matchCounts = matchCounts;
+    }
+
+    private int countMatch(Lotto lotto) {
+        int count = 0;
+        for (int i = 0; i < 6; i++) {
+            count += countMatchNumber(lotto.getNumberByIndex(i));
+        }
+        return count;
+    }
+
+    private void winnerLottoEmptyCheck(Lotto winnerLotto) {
+        if (winnerLotto == null)
+            throw new IllegalArgumentException("우승 번호가 없습니다.");
+    }
+
+    public Boolean containsWinNumbers(List<Integer> numbers) {
+        return winNumberLotto.containsNumbers(numbers);
+    }
+
+    public Integer countMatchNumber(Integer number) {
+        if (containsWinNumbers(Arrays.asList(number)))
+            return 1;
+        return 0;
+    }
+
+    public Integer getWinnerCount(int index) {
+        return this.matchCounts[index];
+    }
+
+    public Integer getPurchaseCount() {
+        return this.purchasedLottos.size();
+    }
+
+}

src/main/java/lotto/domain/LottoFactory.java

@@ -0,0 +1,28 @@
+package lotto.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class LottoFactory {
+
+    private static final List<Integer> numbers =
+            IntStream.rangeClosed(1, 45)
+                    .boxed()
+                    .collect(Collectors.toList());
+
+    private static final Random random = new Random();
+
+    public static Lotto createLotto(List<Integer> lottoNumbers) {
+        return new Lotto(lottoNumbers);
+    }
+
+    public static Lotto createLottoWithRandomNumbers() {
+        List<Integer> copyOfNumbers = new ArrayList<>(numbers);
+        Collections.shuffle(copyOfNumbers, random);
+        return createLotto(copyOfNumbers.subList(0, 6));
+    }
+}

src/main/java/lotto/domain/LottoPrizeCalculator.java

@@ -0,0 +1,23 @@
+package lotto.domain;
+
+public class LottoPrizeCalculator {
+
+    private static final Integer LOTTO_PRICE = 1000;
+    private static final int[] prizeMoney = {0, 0, 0, 5000, 50000, 1500000, 2000000000};
+
+    public static Double calculateRateOfReturn(LottoChecker lottoChecker) {
+        int prize = 0;
+        for (int i = 3; i < 7; i++) {
+            prize += calculatePrizeByNumberAndCount(i, lottoChecker.getWinnerCount(i));
+        }
+        return (double) prize / (lottoChecker.getPurchaseCount() * LOTTO_PRICE);
+    }
+
+    public static Integer calculatePrizeByNumberAndCount(int numberOfMatch, int count) {
+        return count * prizeMoney[numberOfMatch];
+    }
+
+    public static Integer getPrizeByIndex(int index) {
+        return prizeMoney[index];
+    }
+}

src/main/java/lotto/view/LottoInputView.java

@@ -0,0 +1,54 @@
+package lotto.view;
+
+import lotto.domain.Lotto;
+import lotto.domain.LottoFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+import java.util.stream.Collectors;
+
+public class LottoInputView {
+
+    private static Scanner scanner;
+    private static final Integer LOTTO_PRICE = 1000;
+
+    public static void initiateScanner() {
+        scanner = new Scanner(System.in);
+    }
+
+    public static Integer scanAmount() {
+        System.out.println("구입금액을 입력해 주세요.");
+        Integer amount = scanner.nextInt();
+        scanner.nextLine();
+
+        return amount;
+    }
+
+    public static String scanWinNumbers() {
+        System.out.println("지난 주 당첨 번호를 입력해 주세요.");
+        return scanner.nextLine();
+    }
+
+    public static Lotto createLottoWithScan(String numberString) {
+        String[] numbers = numberString.split(", ");
+
+        return LottoFactory.createLotto(
+                Arrays.stream(numbers)
+                        .map(Integer::parseInt)
+                        .collect(Collectors.toList()));
+    }
+
+    public static List<Lotto> createPurchasedLottos(Integer amount) {
+        List<Lotto> purchasedLottos = new ArrayList<>();
+        int count = amount / LOTTO_PRICE;
+
+        for (int i = 0; i < count; i++) {
+            purchasedLottos.add(
+                    LottoFactory.createLottoWithRandomNumbers());
+        }
+
+        return purchasedLottos;
+    }
+}

src/main/java/lotto/view/LottoOutputView.java

@@ -0,0 +1,39 @@
+package lotto.view;
+
+import lotto.domain.Lotto;
+import lotto.domain.LottoChecker;
+import lotto.domain.LottoPrizeCalculator;
+
+import java.util.List;
+
+public class LottoOutputView {
+
+    public static void printPurchaseInfo(List<Lotto> purchaseList) {
+        System.out.println(purchaseList.size() + "개를 구매했습니다.");
+        for (Lotto lotto : purchaseList) {
+            System.out.println("[" + getPurchaseInfoToString(lotto) + "]");
+        }
+        System.out.println();
+    }
+
+    private static String getPurchaseInfoToString(Lotto lotto) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(lotto.getNumberByIndex(0).toString());
+
+        for (int i = 1; i < 6; i++) {
+            sb.append(", " + lotto.getNumberByIndex(i).toString());
+        }
+
+        return sb.toString();
+    }
+
+    public static void printResultInfo(LottoChecker lottoChecker) {
+        System.out.println();
+        System.out.println("당첨 통계");
+        System.out.println("---------");
+        for (int i = 3; i < 7; i++) {
+            System.out.println(i + "개 일치 (" + LottoPrizeCalculator.getPrizeByIndex(i) + "원)-" + lottoChecker.getWinnerCount(i) + "개");
+        }
+        System.out.println("총 수익률은 " + LottoPrizeCalculator.calculateRateOfReturn(lottoChecker) + "입니다.");
+    }
+}

src/main/java/stringCalculator/domain/MathExpression.java

@@ -5,9 +5,9 @@
 
 public class MathExpression {
     private final Queue<Integer> numbers;
-    private final Queue<String> operations;
+    private final Queue<OperationEnum> operations;
 
-    MathExpression(Queue<Integer> numbers, Queue<String> operations) {
+    MathExpression(Queue<Integer> numbers, Queue<OperationEnum> operations) {
         this.numbers = numbers;
         this.operations = operations;
     }
@@ -16,23 +16,23 @@ public Boolean numbersContains(List<Integer> contains) {
         return numbers.containsAll(contains);
     }
 
-    public Boolean operationsContains(List<String> contains) {
+    public Boolean operationsContains(List<OperationEnum> contains) {
         return operations.containsAll(contains);
     }
 
-    public Integer numberPoll(){
+    public Integer numberPoll() {
         return numbers.poll();
     }
 
-    public String operationPoll(){
+    public OperationEnum operationPoll() {
         return operations.poll();
     }
 
-    public Boolean numberHasNext(){
+    public Boolean numberHasNext() {
         return numbers.iterator().hasNext();
     }
 
-    public Boolean operationHasNext(){
+    public Boolean operationHasNext() {
         return operations.iterator().hasNext();
     }
 }