Step2 로또 게임 구현 완료했습니다.

build.gradle

@@ -12,4 +12,5 @@ dependencies {
     compile('ch.qos.logback:logback-classic:1.2.3')
     testCompile('junit:junit:4.12')
     testCompile('org.assertj:assertj-core:3.9.0')
+    testCompile group: 'org.mockito', name: 'mockito-core', version: '3.3.0'
 }

src/main/java/Application.java

@@ -0,0 +1,23 @@
+import lotto.*;
+import view.InputView;
+import view.ResultView;
+
+import java.util.List;
+
+public class Application {
+
+    public static void main(String[] args) {
+        PurchaseMoney purchaseMoney = new PurchaseMoney(InputView.inputPurchaseMoney());
+        LottoGame lottoGame = new LottoGame(purchaseMoney.getMoney(), InputView.inputManualLottoCount());
+        List<String> strings = InputView.inputLottoStrings(lottoGame.getManualLottoCount());
+
+
+        LottoMachine lottoMachine = new LottoMachine();
+        TargetLottos targetLottos = new TargetLottos(lottoMachine.createManualLottos(strings), lottoMachine.createAutoLottos(lottoGame.getAutoLottoCount()));
+        lottoGame.registerTargetLottos(targetLottos);
+
+        ResultView.showAllLottos(lottoGame);
+        WinningLotto winningLotto = new WinningLotto(lottoMachine.createManualLotto(InputView.inputWinningLotto()), InputView.inputBonusNumber());
+        ResultView.showGameResult(lottoGame.createResult(winningLotto));
+    }
+}

src/main/java/lotto/Lotto.java

@@ -0,0 +1,39 @@
+package lotto;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class Lotto {
+
+    private static final int LOTTO_NUMBER_COUNT = 6;
+
+    private List<LottoNumber> lottoNumbers;
+
+    public Lotto(List<LottoNumber> lottoNumbers) {
+        validateSize(lottoNumbers);
+        validateDuplication(lottoNumbers);
+        this.lottoNumbers = lottoNumbers;
+    }
+
+    private void validateSize(List<LottoNumber> lottoNumbers) {
+        if (lottoNumbers.size() != LOTTO_NUMBER_COUNT) {
+            throw new IllegalArgumentException("로또 번호는 6개로 이루어져야 합니다.");
+        }
+    }
+
+    private void validateDuplication(List<LottoNumber> lottoNumbers) {
+        Set<Integer> integers = new HashSet<>(lottoNumbers.stream()
+                .map(LottoNumber::getNumber)
+                .collect(Collectors.toList()));
+        if (integers.size() != LOTTO_NUMBER_COUNT) {
+            throw new IllegalArgumentException("로또 번호는 중복될 수 없습니다.");
+        }
+    }
+
+    public List<LottoNumber> getLottoNumbers() {
+        return lottoNumbers;
+    }
+
+}

src/main/java/lotto/LottoGame.java

@@ -0,0 +1,70 @@
+package lotto;
+
+import java.util.*;
+
+public class LottoGame {
+
+    private static final int LOTTO_PRICE = 1000;
+
+    private int autoLottoCount;
+    private int manualLottoCount;
+    private TargetLottos targetLottos;
+
+    public LottoGame(int money, int manualLottoCount) {
+        this.manualLottoCount = manualLottoCount;
+        this.autoLottoCount = money / LOTTO_PRICE - manualLottoCount;
+    }
+
+    public TargetLottos getTargetLottos() {
+        return targetLottos;
+    }
+
+    public int getManualLottoCount() {
+        return manualLottoCount;
+    }
+
+    public int getAutoLottoCount() {
+        return autoLottoCount;
+    }
+
+    public void registerTargetLottos(TargetLottos targetLottos) {
+        this.targetLottos = targetLottos;
+    }
+
+    public LottoResult createResult(WinningLotto winningLotto) {
+        LottoResult lottoResult = new LottoResult((autoLottoCount + manualLottoCount) * LOTTO_PRICE);
+        for (Lotto lotto : targetLottos.getLottos()) {
+            checkLotto(lotto, lottoResult.getLottoRankResults(), winningLotto);
+        }
+        return lottoResult;
+    }
+
+    private void checkLotto(Lotto lotto, List<LottoRankResult> lottoRankResults, WinningLotto winningLotto) {
+        int countOfMatch = 0;
+        for (LottoNumber lottoNumber : winningLotto.getLotto().getLottoNumbers()) {
+            countOfMatch += checkNumberMatch(lotto, lottoNumber.getNumber());
+        }
+        boolean matchBonus = isBonusMatch(lotto, winningLotto.getBonusNumber());
+        for (LottoRankResult lottoRankResult : lottoRankResults) {
+            lottoRankResult.increaseCount(Rank.valueOf(countOfMatch, matchBonus));
+        }
+    }
+
+    private int checkNumberMatch(Lotto lotto, int number) {
+        for (int index = 0; index < lotto.getLottoNumbers().size(); index++) {
+            if (lotto.getLottoNumbers().get(index).getNumber() == number) {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    private boolean isBonusMatch(Lotto lotto, int bonusNumber) {
+        for (int index = 0; index < lotto.getLottoNumbers().size(); index++) {
+            if (lotto.getLottoNumbers().get(index).getNumber() == bonusNumber) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/main/java/lotto/LottoMachine.java

@@ -0,0 +1,54 @@
+package lotto;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class LottoMachine {
+
+    private static final int LOTTO_SIZE = 6;
+    private static final int MIN_LOTTO_NUMBER = 1;
+    private static final int MAX_LOTTO_NUMBER = 45;
+
+    private List<Integer> integers;
+
+    public LottoMachine() {
+        integers = new ArrayList<>();
+        for (int number = MIN_LOTTO_NUMBER; number <= MAX_LOTTO_NUMBER; number++) {
+            integers.add(number);
+        }
+    }
+
+    public List<Lotto> createAutoLottos(int count) {
+        List<Lotto> lottos = new ArrayList<>();
+        for (int iteration = 0; iteration < count; iteration++) {
+            lottos.add(new Lotto(createLottoNumbers()));
+        }
+        return lottos;
+    }
+
+    public List<Lotto> createManualLottos(List<String> strings) {
+        List<Lotto> lottos = new ArrayList<>();
+        for (String string : strings) {
+            lottos.add(createManualLotto(string));
+        }
+        return lottos;
+    }
+
+    public Lotto createManualLotto(String string) {
+        return new Lotto(Arrays.stream(string.split(","))
+                .map(String::trim)
+                .map(Integer::new)
+                .map(LottoNumber::new)
+                .collect(Collectors.toList()));
+    }
+
+    private List<LottoNumber> createLottoNumbers() {
+        Collections.shuffle(integers);
+        return integers.subList(0, LOTTO_SIZE).stream()
+                .map(LottoNumber::new)
+                .collect(Collectors.toList());
+    }
+}

src/main/java/lotto/LottoNumber.java

@@ -0,0 +1,26 @@
+package lotto;
+
+public class LottoNumber {
+
+
+    private static final int MAX_LOTTO_NUMBER = 45;
+    private static final int MIN_LOTTO_NUMBER = 1;
+
+    private int number;
+
+    public LottoNumber(int number) {
+        validateRange(number);
+        this.number = number;
+    }
+
+    private void validateRange(int number) {
+        if (number > MAX_LOTTO_NUMBER || number < MIN_LOTTO_NUMBER) {
+            throw new IllegalArgumentException("로또 번호는 1이상 45이하의 자연수만 가능합니다.");
+        }
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+}

src/main/java/lotto/LottoRankResult.java

@@ -0,0 +1,30 @@
+package lotto;
+
+public class LottoRankResult {
+
+    Rank rank;
+    int count;
+
+    public LottoRankResult(Rank rank) {
+        this.rank = rank;
+        this.count = 0;
+    }
+
+    public Rank getRank() {
+        return rank;
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+    public void increaseCount(Rank rank) {
+        if (this.rank == rank) {
+            count++;
+        }
+    }
+
+    public int getWinningMoney() {
+        return rank.getWinningMoney() * count;
+    }
+}

src/main/java/lotto/LottoResult.java

@@ -0,0 +1,31 @@
+package lotto;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LottoResult {
+
+    private List<LottoRankResult> lottoRankResults;
+    private int money;
+
+    public LottoResult(int money) {
+        this.money = money;
+        lottoRankResults = new ArrayList<>();
+        for (int index = 0; index < Rank.values().length; index++) {
+            lottoRankResults.add(new LottoRankResult(Rank.values()[index]));
+        }
+    }
+
+    public List<LottoRankResult> getLottoRankResults() {
+        return lottoRankResults;
+    }
+
+    public double createRateOfProfit() {
+        int profit = 0;
+        for (LottoRankResult lottoRankResult : lottoRankResults) {
+            profit += lottoRankResult.getWinningMoney();
+        }
+        return (double) profit / money;
+    }
+
+}