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();
+        WinningLotto winningLotto = InputView.readWinningLottoInput();
 
         OutputView.printPurchaseCount(purchaseAmount.countLottoTickets());
         Lottos lottos = purchaseAmount.buyLottos();
         OutputView.printBoughtLottos(lottos);
 
-        LottoResults result = lottos.calculateResults(winningLotto);
+        LottoResults result = LottoResultCalculator.calculate(lottos, 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(LottoNumberFactory::get).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(LottoNumberFactory::get).collect(Collectors.toSet());
     }
 }

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

@@ -2,7 +2,7 @@
 
 import java.util.Objects;
 
-public class LottoNumber {
+public class LottoNumber implements Comparable<LottoNumber> {
     private final int number;
 
     public LottoNumber(int number) {
@@ -36,4 +36,9 @@ public int hashCode() {
     public String toString() {
         return String.valueOf(number);
     }
+
+    @Override
+    public int compareTo(LottoNumber another) {
+        return Integer.compare(this.number, another.number);
+    }
 }

src/main/java/lotto/model/LottoNumberFactory.java

@@ -0,0 +1,25 @@
+package lotto.model;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.IntStream;
+
+public class LottoNumberFactory {
+    private final static Map<Integer, LottoNumber> CACHE;
+
+    static {
+        CACHE = new ConcurrentHashMap<>();
+        IntStream.rangeClosed(1, 45).forEach(i -> CACHE.put(i, new LottoNumber(i)));
+    }
+
+    public static LottoNumber get(String number) {
+        return get(Integer.parseInt(number));
+    }
+
+    public static LottoNumber get(Integer number) {
+        if (CACHE.get(number) == null) {
+            throw new IllegalArgumentException("로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+        }
+        return CACHE.get(number);
+    }
+}

src/main/java/lotto/model/LottoResultCalculator.java

@@ -0,0 +1,11 @@
+package lotto.model;
+
+public class LottoResultCalculator {
+    public static LottoResults calculate(Lottos lottos, WinningLotto winningLotto) {
+        LottoResults lottoResults = new LottoResults();
+        for (Lotto lotto : lottos.lottos()) {
+            lottoResults.update(winningLotto.calculatePrize(lotto));
+        }
+        return lottoResults;
+    }
+}

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

@@ -1,59 +1,48 @@
 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 long getPrizeValue() {
-        return matchCounts.entrySet().stream()
-                .mapToLong(entry -> (long) entry.getValue() * Prize.fromMatchCount(entry.getKey()).value())
+    public long getTotalPrizeValue() {
+        return prizeCounts.entrySet().stream()
+                .mapToLong(entry -> (long) entry.getValue() * entry.getKey().value())
                 .sum();
     }
 
     public double getReturnRate(PurchaseAmount purchaseAmount) {
-        long totalPrize = getPrizeValue();
+        long totalPrize = getTotalPrizeValue();
         return purchaseAmount.getReturnRate(totalPrize);
     }
 
-    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,37 @@
 package lotto.model;
 
 import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.Collections;
 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 List<Lotto> lottos() {
+        return Collections.unmodifiableList(lottos);
     }
 
     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/Prize.java

@@ -4,10 +4,12 @@
 import java.util.Arrays;
 
 public enum Prize {
-    THREE_MATCHES(3, 5_000),
-    FOUR_MATCHES(4, 50_000),
-    FIVE_MATCHES(5, 1_500_000),
-    SIX_MATCHES(6, 2_000_000_000);
+    MISS(0, 0),
+    FIFTH(3, 5_000),
+    FOURTH(4, 50_000),
+    THIRD(5, 1_500_000),
+    SECOND(5, 30_000_000),
+    FIRST(6, 2_000_000_000);
 
     private final int matchCount;
     private final int prizeValue;
@@ -23,13 +25,22 @@ public int value() {
 
     @Override
     public String toString() {
-        return String.format("%d개 일치 (%s원)", matchCount, prizeValue);
+        if (this.equals(SECOND)) {
+            return String.format("%d개 일치, 보너스 볼 일치(%s원)", matchCount, prizeValue);
+        }
+        return String.format("%d개 일치(%s원)", matchCount, prizeValue);
     }
 
-    static Prize fromMatchCount(int matchCount) {
+    static Prize valueOf(int matchCount, boolean matchBonus) {
+        if (matchCount < 3) {
+            return MISS;
+        }
+        if (matchCount == 5 && matchBonus) {
+            return SECOND;
+        }
         return Arrays.stream(Prize.values())
                 .filter(prize -> prize.matchCount == matchCount)
                 .findFirst()
-                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 일치 값입니다. " + matchCount));
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 일치 값입니다. " + matchCount + matchBonus));
     }
 }

src/main/java/lotto/model/WinningLotto.java

@@ -0,0 +1,20 @@
+package lotto.model;
+
+public class WinningLotto {
+    private final Lotto winningLotto;
+    private final LottoNumber bonusNumber;
+
+    public WinningLotto(Lotto lotto, LottoNumber bonusNumber) {
+        if (lotto.contains(bonusNumber)) {
+            throw new IllegalArgumentException("당첨 번호는 보너스볼의 번호를 포함할 수 없습니다.");
+        }
+        this.winningLotto = lotto;
+        this.bonusNumber = bonusNumber;
+    }
+
+    public Prize calculatePrize(Lotto lotto) {
+        int matchCount = lotto.countMatchNumbers(winningLotto);
+        boolean matchBonus = lotto.matchesBonusNumber(bonusNumber);
+        return Prize.valueOf(matchCount, matchBonus);
+    }
+}