3단계 - 로또(2등)

src/main/java/lotto/LottoApplication.java

@@ -1,22 +1,19 @@
 package lotto;
 
-import lotto.model.PurchaseAmount;
-import lotto.model.Lotto;
-import lotto.model.LottoResults;
-import lotto.model.Lottos;
+import lotto.model.*;
 import lotto.view.InputView;
 import lotto.view.OutputView;
 
 public class LottoApplication {
     public static void main(String[] args) {
-        PurchaseAmount purchaseAmount = InputView.readBudgetInput();
-        Lotto winningLotto = InputView.readWinningLottoInput();
+        Money purchaseAmount = InputView.readPurchaseAmountInput();
+        WinningLotto winningLotto = InputView.readWinningLottoInput();
 
         OutputView.printPurchaseCount(purchaseAmount.countLottoTickets());
         Lottos lottos = purchaseAmount.buyLottos();
         OutputView.printBoughtLottos(lottos);
 
-        LottoResults result = lottos.calculateResults(winningLotto);
+        LottoResults result = lottos.match(winningLotto);
         OutputView.printResults(result, purchaseAmount);
     }
 }

src/main/java/lotto/README.md

@@ -4,7 +4,9 @@
 - 로또 구입 금액을 입력하면 구입 금액에 해당하는 로또를 발급한다. (로또 1장에 1,000원)
 - 로또 번호는 1부터 45까지의 숫자 중 6개를 랜덤으로 선택한다.
 - 당첨 번호 6개를 입력하면, 구입한 로또와 비교하여 당첨 결과를 알려준다.
+- 보너스 번호를 뽑아 당첨 번호 5개와 보너스 번호 1개가 일치하는 로또는 2등상을 준다.
 - 당첨 결과는 3개, 4개, 5개, 6개 일치에 따라 각각 5,000원, 50,000원, 1,500,000원, 2,000,000,000원의 상금을 지급한다.
+- 2등은 30,000,000원을 지급한다.
 - 수익률을 계산하여 출력한다. (수익률 = 총 당첨 금액 / 구입 금액)
   - 수익률은 소수점 둘째 자리까지 표시한다.
   - 1 이상인 경우 이익, 1 미만인 경우 손해로 표시한다.

src/main/java/lotto/model/Lotto.java

@@ -1,68 +1,54 @@
 package lotto.model;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public class Lotto {
-    private final List<LottoNumber> numbers;
+    private final static int LOTTO_NUMBER_SIZE = 6;
+    private final static List<Integer> rangedInts = IntStream.rangeClosed(1, 45).boxed().collect(Collectors.toList());
+    private final Set<LottoNumber> numbers;
 
     public Lotto() {
         this(generateRandomNumbers());
     }
 
     public Lotto(int... numbers) {
-        this(Arrays.stream(numbers).boxed().collect(Collectors.toList()));
+        this(Arrays.stream(numbers).mapToObj(LottoNumber::of).collect(Collectors.toSet()));
     }
 
-    public Lotto(List<Integer> numbers) {
+    public Lotto(Set<LottoNumber> numbers) {
         checkValidity(numbers);
-        Collections.sort(numbers);
-        this.numbers = numbers.stream().map(LottoNumber::new).collect(Collectors.toList());
-    }
-
-    public List<LottoNumber> value() {
-        return Collections.unmodifiableList(this.numbers);
+        this.numbers = numbers;
     }
 
     public int countMatchNumbers(Lotto lotto) {
-        int matchCount = 0;
-        for (LottoNumber number : this.numbers) {
-            matchCount += addMatchCount(number, lotto);
-        }
-        return matchCount;
+        return Math.toIntExact(this.numbers.stream().filter(lotto::contains).count());
     }
 
-    private void checkValidity(List<Integer> numbers) {
-        if (numbers.size() != 6) {
-            throw new IllegalArgumentException("로또 번호는 6개여야 합니다.");
-        }
-        if (hasDuplicated(numbers)) {
-            throw new IllegalArgumentException("로또 번호는 중복될 수 없습니다.");
-        }
+    public boolean matchesBonusNumber(LottoNumber bonusNumber) {
+        return contains(bonusNumber);
     }
 
-    private boolean hasDuplicated(List<Integer> numbers) {
-        long distinctCount = numbers.stream().distinct().count();
-        return distinctCount != numbers.size();
+    @Override
+    public String toString() {
+        List<LottoNumber> lottoNumbers = new ArrayList<>(this.numbers);
+        Collections.sort(lottoNumbers);
+        return lottoNumbers.toString();
     }
 
-    private int addMatchCount(LottoNumber number, Lotto lotto) {
-        if (lotto.contains(number)) {
-            return 1;
-        }
-        return 0;
+    public boolean contains(LottoNumber number) {
+        return numbers.contains(number);
     }
 
-    private boolean contains(LottoNumber number) {
-        return numbers.contains(number);
+    private void checkValidity(Set<LottoNumber> numbers) {
+        if (numbers.size() != LOTTO_NUMBER_SIZE) {
+            throw new IllegalArgumentException("로또 번호는 6개여야 합니다.");
+        }
     }
 
-    private static List<Integer> generateRandomNumbers() {
-        List<Integer> array = IntStream.rangeClosed(1, 45).boxed().collect(Collectors.toList());
-        Collections.shuffle(array);
-        return array.subList(0, 6);
+    private static Set<LottoNumber> generateRandomNumbers() {
+        Collections.shuffle(rangedInts);
+        return rangedInts.subList(0, LOTTO_NUMBER_SIZE).stream().map(LottoNumber::of).collect(Collectors.toSet());
     }
 }

src/main/java/lotto/model/LottoNumber.java

@@ -1,19 +1,22 @@
 package lotto.model;
 
+import java.util.Map;
 import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.IntStream;
 
-public class LottoNumber {
-    private final int number;
+public class LottoNumber implements Comparable<LottoNumber> {
+    private final static Map<Integer, LottoNumber> CACHE;
 
-    public LottoNumber(int number) {
-        if (!isValid(number)) {
-            throw new IllegalArgumentException("로또 번호는 1부터 45 사이의 숫자여야 합니다.");
-        }
-        this.number = number;
+    static {
+        CACHE = new ConcurrentHashMap<>();
+        IntStream.rangeClosed(1, 45).forEach(i -> CACHE.put(i, new LottoNumber(i)));
     }
 
-    private boolean isValid(int number) {
-        return number >= 1 && number <= 45;
+    private final int number;
+
+    private LottoNumber(int number) {
+        this.number = number;
     }
 
     public int getNumber() {
@@ -36,4 +39,24 @@ public int hashCode() {
     public String toString() {
         return String.valueOf(number);
     }
+
+    @Override
+    public int compareTo(LottoNumber another) {
+        return Integer.compare(this.number, another.number);
+    }
+
+    private static boolean isValid(int number) {
+        return CACHE.containsKey(number);
+    }
+
+    public static LottoNumber of(int number) {
+        if (!isValid(number)) {
+            throw new IllegalArgumentException("로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+        }
+        return CACHE.get(number);
+    }
+
+    public static LottoNumber of(String input) {
+        return of(Integer.parseInt(input));
+    }
 }

src/main/java/lotto/model/LottoResults.java

@@ -1,59 +1,56 @@
 package lotto.model;
 
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 
 public class LottoResults {
-    private final Map<Integer, Integer> matchCounts;
+    private final Map<Prize, Integer> prizeCounts;
 
     public LottoResults() {
         this(new HashMap<>());
     }
 
-    public LottoResults(Map<Integer, Integer> matchCounts) {
-        this.matchCounts = matchCounts;
+    public LottoResults(Map<Prize, Integer> prizeCounts) {
+        this.prizeCounts = prizeCounts;
     }
 
-    public void updateMatchCount(int matchCount) {
-        if (matchCount < 3) {
-            return;
-        }
-        matchCounts.put(matchCount, matchCounts.getOrDefault(matchCount, 0) + 1);
+    public void update(Prize prize) {
+        prizeCounts.put(prize, prizeCounts.getOrDefault(prize, 0) + 1);
+    }
+
+    public Money getTotalPrizeValue() {
+        return new Money(prizeCounts.entrySet().stream()
+                .mapToLong(entry -> (long) entry.getValue() * entry.getKey().value())
+                .sum());
     }
 
-    public long getPrizeValue() {
-        return matchCounts.entrySet().stream()
-                .mapToLong(entry -> (long) entry.getValue() * Prize.fromMatchCount(entry.getKey()).value())
-                .sum();
+    public double getReturnRate(Money purchaseAmount) {
+        Money totalPrize = getTotalPrizeValue();
+        return calculateReturnRate(purchaseAmount, totalPrize);
     }
 
-    public double getReturnRate(PurchaseAmount purchaseAmount) {
-        long totalPrize = getPrizeValue();
-        return purchaseAmount.getReturnRate(totalPrize);
+    private double calculateReturnRate(Money purchaseAmount, Money totalPrize) {
+        if (purchaseAmount.isZero()) {
+            return 0;
+        }
+        double rate = totalPrize.divideBy(purchaseAmount);
+        return Math.floor(rate * 100) / 100.0;
     }
 
-    public Integer getMatchCount(int matchCount) {
-        return matchCounts.getOrDefault(matchCount, 0);
+    public Integer getPrizeCount(Prize prize) {
+        return prizeCounts.getOrDefault(prize, 0);
     }
 
     @Override
     public boolean equals(Object o) {
         if (o == null || getClass() != o.getClass()) return false;
         LottoResults that = (LottoResults) o;
-        return Objects.equals(matchCounts, that.matchCounts);
+        return Objects.equals(prizeCounts, that.prizeCounts);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hashCode(matchCounts);
-    }
-
-    @Override
-    public String toString() {
-        return "LottoResults{" +
-                "matchCounts=" + matchCounts +
-                '}';
+        return Objects.hashCode(prizeCounts);
     }
 }

src/main/java/lotto/model/Lottos.java

@@ -1,46 +1,41 @@
 package lotto.model;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
 public class Lottos {
     private final List<Lotto> lottos;
 
     public Lottos(int count) {
-        this(new ArrayList<>());
-        for (int i = 0; i < count; i++) {
-            lottos.add(new Lotto());
-        }
+        this(createLottos(count));
     }
 
     public Lottos(List<Lotto> lottos) {
         this.lottos = lottos;
     }
 
-    public LottoResults calculateResults(Lotto winningLotto) {
-        LottoResults results = new LottoResults();
-
-        for (Lotto lotto : lottos) {
-            int matchCount = lotto.countMatchNumbers(winningLotto);
-            results.updateMatchCount(matchCount);
-        }
-
-        return results;
-    }
-
-    private void addMatchCount(int matchCount, List<Integer> results) {
-        if (matchCount >= 3 && matchCount <= 6) {
-            int idx = matchCount - 3;
-            results.set(idx, results.get(idx) + 1);
+    public LottoResults match(WinningLotto winningLotto) {
+        LottoResults lottoResults = new LottoResults();
+        for (Lotto lotto : this.lottos) {
+            lottoResults.update(winningLotto.calculatePrize(lotto));
         }
+        return lottoResults;
     }
 
+    @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
         for (Lotto lotto : lottos) {
-            sb.append(lotto.value().toString()).append("\n");
+            sb.append(lotto.toString()).append("\n");
         }
         return sb.toString();
     }
+
+    private static List<Lotto> createLottos(int count) {
+        List<Lotto> lottos = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            lottos.add(new Lotto());
+        }
+        return lottos;
+    }
 }

src/main/java/lotto/model/PurchaseAmount.java → src/main/java/lotto/model/Money.java

@@ -2,41 +2,45 @@
 
 import java.util.Objects;
 
-public class PurchaseAmount {
-    private final int amount;
+public class Money {
+    private final long amount;
 
-    public PurchaseAmount(int amount) {
+    public Money(int amount) {
+        this((long) amount);
+    }
+
+    public Money(long amount) {
         if (!isValid(amount)) {
             throw new IllegalArgumentException("예산은 0 이상이며 1000원 단위로만 설정 가능합니다.");
         }
         this.amount = amount;
     }
 
     public int countLottoTickets() {
-        return amount / 1_000;
+        return Math.toIntExact(amount / 1_000L);
     }
 
     public Lottos buyLottos() {
         return new Lottos(countLottoTickets());
     }
 
-    public double getReturnRate(Long totalPrize) {
-        if (amount == 0) {
-            return 0;
-        }
-        double rate = (double) totalPrize / amount;
-        return Math.floor(rate * 100) / 100.0;
+    public boolean isZero() {
+        return amount == 0;
+    }
+
+    public double divideBy(Money money) {
+        return (double) this.amount / money.amount;
     }
 
-    private boolean isValid(int amount) {
+    private boolean isValid(Long amount) {
         return amount >= 0 && amount % 1000 == 0;
     }
 
     @Override
     public boolean equals(Object o) {
         if (o == null || getClass() != o.getClass()) return false;
-        PurchaseAmount purchaseAmount = (PurchaseAmount) o;
-        return amount == purchaseAmount.amount;
+        Money money = (Money) o;
+        return amount == money.amount;
     }
 
     @Override