Step4 - 로또(수동)

src/main/java/step2/controller/LottoGameController.java

@@ -1,73 +1,75 @@
 package step2.controller;
 
-import step2.domain.LottoCommonValue;
-import step2.domain.LottoGames;
-import step2.domain.LottoResultReport;
-import step2.domain.LottoTicket;
+import step2.domain.*;
 import step2.view.InputView;
 import step2.view.ResultView;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 public class LottoGameController {
 
+    private static final int LOTTO_TICKET_PRICE = 1000;
     private LottoGames lottoGames = new LottoGames();
 
     public void playLottoGame() {
+        Money balance = new Money(InputView.readMoney());
 
-        int money = InputView.readAmountOfPurchase();
-        int manualLottoTicketCount = InputView.readCountOfManualTicket();
-        List<LottoTicket> manualLottoTickets = buyManualTickets(money, manualLottoTicketCount);
+        List<LottoTicket> manualLottoTickets = buyManualTickets(balance);
+        List<LottoTicket> automaticLottoTickets = getBuyAutomaticTickets(balance);
 
-        int automaticTicketCount = lottoGames.calculateBuyingTicketCount(money, manualLottoTicketCount);
-        ResultView.printNumberOfTickets(manualLottoTicketCount, automaticTicketCount);
-        if (automaticTicketCount == 0 && manualLottoTicketCount == 0) {
+        ResultView.printNumberOfTickets(manualLottoTickets.size(), automaticLottoTickets.size());
+        if (manualLottoTickets.size() == 0 && automaticLottoTickets.size() == 0) {
             return;
         }
-
-        List<LottoTicket> automaticLottoTickets = getBuyAutomaticTickets(automaticTicketCount);
         ResultView.printLottoTicket(automaticLottoTickets);
         LottoTicket winningTicket = readWinningTicket();
-        int bonusNumber = InputView.readBonusNumber();
-
-        ResultView.printBlankLine();
-        ResultView.printMessage("당첨 통계");
+        LottoNo bonusNumber = LottoNo.of(InputView.readBonusNumber());
 
-        LottoResultReport lottoResultReport = getLottoResultReport(manualLottoTickets, automaticLottoTickets, winningTicket, bonusNumber);
-
-        ResultView.printResultReport(lottoResultReport);
-        double profit = lottoResultReport.calculateProfit(manualLottoTicketCount + automaticTicketCount);
-        ResultView.printMessage("총 수익률은 " + profit + "입니다.");
+        printResultStatistic(getLottoResultReport(manualLottoTickets, automaticLottoTickets, winningTicket, bonusNumber));
     }
 
-    private List<LottoTicket> buyManualTickets(int totalMoney, int manualTicketCount) {
-        if(manualTicketCount * LottoCommonValue.DEFAULT_LOTTO_PRICE.value() > totalMoney) {
-            throw new IllegalArgumentException("수동으로 구매할 수 있는 티켓 개수를 초과하셨습니다.");
-        }
+    private List<LottoTicket> buyManualTickets(Money money) {
+        int manualTicketCount = getManualTicketCount(money);
+        money.pay(manualTicketCount * LOTTO_TICKET_PRICE);
+
         ResultView.printMessage("수동으로 구매할 번호를 입력해 주세요");
-        List<LottoTicket> manualLottoTickets = new ArrayList<>();
-        for(int i=0; i<manualTicketCount; i++) {
-            Optional<LottoTicket> lottoTicket = lottoGames.toLottoTicket(InputView.readManualTicketNumbers());
-            manualLottoTickets.add(lottoTicket.orElseThrow(IllegalArgumentException::new));
+        List<LottoTicket> manualLottoTickets = new ArrayList<>(manualTicketCount);
+        for (int i = 0; i < manualTicketCount; i++) {
+            LottoTicket lottoTicket = lottoGames.toLottoTicket(InputView.readManualTicketNumbers());
+            manualLottoTickets.add(lottoTicket);
         }
         return manualLottoTickets;
     }
 
-    private List<LottoTicket> getBuyAutomaticTickets(int automaticTicketCount) {
+    private int getManualTicketCount(Money money) {
+        int manualTicketCount = InputView.readCountOfManualTicket();
+        int cost = manualTicketCount * LottoCommonValue.DEFAULT_LOTTO_NUMBER_COUNT.value();
+        money.pay(cost);
+        return manualTicketCount;
+    }
+
+    private List<LottoTicket> getBuyAutomaticTickets(Money money) {
+        int automaticTicketCount = money.balance() / LOTTO_TICKET_PRICE;
+        money.pay(automaticTicketCount * LOTTO_TICKET_PRICE);
         return lottoGames.buyAutomaticLottoTickets(automaticTicketCount);
     }
 
     private LottoTicket readWinningTicket() {
         ResultView.printMessage("지난 주 당첨 번호를 입력해 주세요");
-        return lottoGames.toLottoTicket(InputView.readWinningNumbers())
-                .orElseThrow(() -> new IllegalArgumentException("잘못 입력하셨습니다."));
+        return lottoGames.toLottoTicket(InputView.readWinningNumbers());
+    }
+
+    private void printResultStatistic(LottoResultReport lottoResultReport) {
+        ResultView.printBlankLine();
+        ResultView.printMessage("당첨 통계");
+        ResultView.printResultReport(lottoResultReport);
+        ResultView.printMessage("총 수익률은 " + lottoResultReport.calculateProfit() + "입니다.");
     }
 
     private LottoResultReport getLottoResultReport(List<LottoTicket> manualLottoTickets,
                                                    List<LottoTicket> automaticLottoTickets,
-                                                   LottoTicket winningTicket, int bonusNumber) {
+                                                   LottoTicket winningTicket, LottoNo bonusNumber) {
 
         LottoResultReport lottoResultReport = new LottoResultReport();
         for (LottoTicket lottoTicket : manualLottoTickets) {

src/main/java/step2/domain/LottoCommonValue.java

@@ -16,9 +16,4 @@ public enum LottoCommonValue {
     public int value() {
         return value;
     }
-
-
-
-
-
 }

src/main/java/step2/domain/LottoGames.java

@@ -8,11 +8,6 @@ public class LottoGames {
     public LottoGames() {
     }
 
-    public int calculateBuyingTicketCount(int money, int manualLottoTicketCount) {
-        money -= manualLottoTicketCount * LottoCommonValue.DEFAULT_LOTTO_PRICE.value();
-        return new Integer(money / LottoCommonValue.DEFAULT_LOTTO_PRICE.value());
-    }
-
     public List<LottoTicket> buyAutomaticLottoTickets(int gameCount) {
         List<LottoTicket> lottoTickets = new ArrayList<>(gameCount);
         for (int i = 0; i < gameCount; i++) {
@@ -28,18 +23,8 @@ private LottoTicket createLottoGame() {
         return new LottoTicket(lottoNumbers);
     }
 
-    public Optional<LottoTicket> toLottoTicket(String stringNumber) {
-        String[] splits = splitByDelimiter(stringNumber);
-        Set<LottoNo> numbers = toSet(splits);
-        if (numbers.size() != LottoCommonValue.DEFAULT_LOTTO_NUMBER_COUNT.value()) {
-            return Optional.empty();
-        }
-        return Optional.ofNullable(new LottoTicket(numbers));
-    }
-
-    private String[] splitByDelimiter(String stringNumber) {
-        stringNumber = stringNumber.replaceAll(" ", "");
-        return stringNumber.split(",");
+    public LottoTicket toLottoTicket(String[] splits) {
+        return new LottoTicket(toSet(splits));
     }
 
     private Set<LottoNo> toSet(String[] numbers) {
@@ -51,6 +36,7 @@ private Set<LottoNo> toSet(String[] numbers) {
     }
 
     private Integer toInt(String element) {
+        element = element.trim();
         try {
             return Integer.parseInt(element);
         } catch (NumberFormatException e) {

src/main/java/step2/domain/LottoNo.java

@@ -3,14 +3,13 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.stream.IntStream;
 
 public class LottoNo {
     private static final int MIN_LOTTO_NUMBER = 1;
     private static final int MAX_LOTTO_NUMBER = 45;
 
-    private static Map<Integer, LottoNo> lottoNumberCache = new HashMap<>();
+    private static final Map<Integer, LottoNo> lottoNumberCache = new HashMap<>();
 
     static {
         IntStream.range(MIN_LOTTO_NUMBER, MAX_LOTTO_NUMBER + 1)
@@ -24,8 +23,14 @@ private LottoNo(int number) {
     }
 
     public static LottoNo of(int number) {
-        Optional<LottoNo> lottoNo = Optional.ofNullable(lottoNumberCache.get(number));
-        return lottoNo.orElseThrow(() -> new IllegalArgumentException("잘못 입력하셨습니다."));
+        if (isInvalidNumber(number)) {
+            throw new IllegalArgumentException("잘못 입력하셨습니다.");
+        }
+        return lottoNumberCache.get(number);
+    }
+
+    private static boolean isInvalidNumber(int number) {
+        return number < MIN_LOTTO_NUMBER || number > MAX_LOTTO_NUMBER;
     }
 
     public int number() {

src/main/java/step2/domain/LottoResultReport.java

@@ -7,22 +7,32 @@
 public class LottoResultReport {
 
     private Map<Rank, Integer> lottoResultReport;
+    private int ticketCount;
 
     public LottoResultReport() {
         lottoResultReport = new HashMap<>();
+        ticketCount = 0;
     }
 
     public int recordRank(Rank rank) {
-        return lottoResultReport.compute(rank, (key, value) -> value == null ? 1 : value + 1);
+        ticketCount += 1;
+        return lottoResultReport.compute(rank, (key, value) -> getNextValue(value));
+    }
+
+    private int getNextValue(Integer value) {
+        if(value == null) {
+            return 1;
+        }
+        return value + 1;
     }
 
     public int findReportByMatchCount(Rank rank) {
         return lottoResultReport.getOrDefault(rank, 0);
     }
 
-    public double calculateProfit(int gameCount) {
+    public double calculateProfit() {
         long profit = sum();
-        long cost = gameCount * LottoCommonValue.DEFAULT_LOTTO_PRICE.value();
+        long cost = ticketCount * LottoCommonValue.DEFAULT_LOTTO_PRICE.value();
         return calculateProfitRate(profit, cost);
     }
 

src/main/java/step2/domain/LottoTicket.java

@@ -4,6 +4,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 public class LottoTicket {
 
@@ -29,20 +30,17 @@ public boolean isContain(LottoNo number) {
         return this.lottoTicket.contains(number);
     }
 
-    public Rank checkLottoTicket(LottoTicket winningTicket, int bonusNumber) {
+    public Rank checkLottoTicket(LottoTicket winningTicket, LottoNo bonusNumber) {
         int count = (int) lottoTicket.stream()
                 .filter(i -> winningTicket.isContain(i))
                 .count();
 
-        return Rank.toPrizeMoney(count, isContain(LottoNo.of(bonusNumber)));
+        return Rank.rank(count, isContain(bonusNumber));
     }
 
     public String printTicket() {
-        StringBuilder stringBuilder = new StringBuilder();
-        lottoTicket.stream()
-                .forEach(lottoNo -> stringBuilder.append(lottoNo.number() + ", "));
-        stringBuilder.deleteCharAt(stringBuilder.length() - 1);
-        return stringBuilder.toString();
+        return lottoTicket.stream()
+                .map(i -> String.valueOf(i.number()))
+                .collect(Collectors.joining(","));
     }
-
 }

src/main/java/step2/domain/Money.java

@@ -0,0 +1,39 @@
+package step2.domain;
+
+import java.util.Objects;
+
+public class Money {
+    private int money;
+
+    public Money(int money) {
+        if (money < 0) {
+            throw new IllegalArgumentException("잔액은 음수를 가질 수 없습니다.");
+        }
+        this.money = money;
+    }
+
+    public int pay(int cost) {
+        if (cost > this.money) {
+            throw new IllegalArgumentException("잔액을 초과하셨습니다.");
+        }
+        this.money -= cost;
+        return 0;
+    }
+
+    public int balance() {
+        return money;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Money money1 = (Money) o;
+        return money == money1.money;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(money);
+    }
+}

src/main/java/step2/domain/Rank.java

@@ -1,41 +1,38 @@
 package step2.domain;
 
 import java.util.Arrays;
-import java.util.function.BiPredicate;
 
 public enum Rank {
-    MISS(0, 0, "0개 일치 (0)", (matchCount, hasBonus) -> matchCount < 3),
-    FIFTH(3, 5_000, "3개 일치 (5000)", (matchCount, hasBonus) -> matchCount == 3),
-    FOURTH(4, 50_000, "4개 일치 (50000)", (matchCount, hasBonus) -> matchCount == 4),
-    THIRD(5, 1_500_000, "5개 일치 (1500000)", (matchCount, hasBonus) -> matchCount == 5 && !hasBonus),
-    SECOND(5, 30_000_000, "5개 일치, 보너스 볼 일치(30000000원)", (matchCount, hasBonus) -> matchCount == 5 && hasBonus),
-    FIRST(6, 2_000_000_000, "6개 일치 (2000000000)", (matchCount, hasBonus) -> matchCount == 6);
-
-    private static final int THIRD_COUNT = 5;
+    MISS(0, 0, "0개 일치 (0)"),
+    FIFTH(3, 5_000, "3개 일치 (5000)"),
+    FOURTH(4, 50_000, "4개 일치 (50000)"),
+    THIRD(5, 1_500_000, "5개 일치 (1500000)"),
+    SECOND(5, 30_000_000, "5개 일치, 보너스 볼 일치(30000000원)"),
+    FIRST(6, 2_000_000_000, "6개 일치 (2000000000)");
 
     private int matchCount;
     private long prizeMoney;
-    private BiPredicate<Integer, Boolean> predicate;
-
     private String message;
 
-    Rank(int matchCount, long rank, String message, BiPredicate<Integer, Boolean> predicate) {
+    Rank(int matchCount, long rank, String message) {
         this.matchCount = matchCount;
         this.prizeMoney = rank;
         this.message = message;
-        this.predicate = predicate;
     }
 
-    public static Rank toPrizeMoney(int matchCount, boolean hasBonus) {
+    public static Rank rank(int matchCount, boolean matchBonus) {
+        if (matchCount < FIFTH.matchCount) {
+            return MISS;
+        }
 
-        return Arrays.stream(values())
-                .filter(prizeMoney -> prizeMoney.predicate.test(matchCount, hasBonus))
-                .findAny()
-                .orElse(Rank.MISS);
-    }
+        if (SECOND.isSameMathCount(matchCount)) {
+            return rankSecondOrThird(matchBonus);
+        }
 
-    public int matchCount() {
-        return this.matchCount;
+        return Arrays.stream(values())
+                .filter(rank -> rank.isSameMathCount(matchCount))
+                .findFirst()
+                .orElseThrow(IllegalArgumentException::new);
     }
 
     public long prizeMoney() {
@@ -49,4 +46,11 @@ public String message() {
     private boolean isSameMathCount(int matchCount) {
         return this.matchCount == matchCount;
     }
+
+    private static Rank rankSecondOrThird(boolean matchBonus) {
+        if (matchBonus) {
+            return SECOND;
+        }
+        return THIRD;
+    }
 }