🚀 3단계 - 로또(2등) (#4209)

* 불변 리스트 반환하도록 변경

* 🚀 3단계 - 로또(2등) : README 업데이트

* 2등, 3등 구분 위해 보너스 번호 확인 기능 추가

* 코드 정리

* 3단계 피드백 반영

* 피드백 : 일급콜렉션 적용, 객체 협력

Author: Eundms

src/main/java/lotto/LottoGameApplication.java

@@ -2,10 +2,10 @@
 
 import lotto.domain.game.LottoGame;
 import lotto.domain.game.LottoMachine;
-import lotto.domain.lotto.LottoTicket;
 import lotto.domain.lotto.Money;
-import lotto.domain.result.GameResult;
 import lotto.domain.lotto.Purchase;
+import lotto.domain.lotto.WinningTicket;
+import lotto.domain.result.GameResult;
 import lotto.ui.InputView;
 import lotto.ui.ResultView;
 
@@ -19,11 +19,12 @@ public static void main(String[] args) {
     ResultView.printPurchase(purchase);
 
     String winningLottoNumbers = InputView.inputWinningLottoNumbers();
-    LottoTicket winning = LottoTicket.from(winningLottoNumbers);
+    int bonusNumber = InputView.inputBonusNumber();
+    WinningTicket winning = new WinningTicket(winningLottoNumbers, bonusNumber);
 
     LottoGame game = new LottoGame(winning);
     GameResult gameResult = game.check(purchase);
 
-    ResultView.printResult(gameResult);
+    ResultView.printResult(gameResult, purchase.getPurchaseAmount());
   }
 }

src/main/java/lotto/README.md

@@ -4,9 +4,10 @@
 
 1. 구입 금액 입력 기능
 2. N개의 로또 구매 기능 (자동)
-3. 당첨 번호 입력 기능
+3. 당첨 번호 입력 기능 (당첨 번호 6개 + 보너스볼 1개)
 4. 당첨 통계 조회 기능
     - 몇 개의 번호가 일치하는지, 몇 개인지
+    - 보너스볼 일치 여부 (5개 일치 시)
     - 수익률
 
 # 주요 객체
@@ -15,7 +16,8 @@
 
 - 무엇인가? : 구매금에 따라 로또를 생성해주는 머신
 - 역할
-    - 로또 발급 개수
+    - 로또 발급 개수 계산
+    - 랜덤 로또 티켓 생성
 
 ## 로또 (LottoTicket)
 
@@ -31,32 +33,54 @@
     - 번호 유효성 보장 (1 ~ 45)
     - 숫자 객체 비교
 
-## 당첨된 로또 (WinningLotto)
+## 금액 (Money)
 
-- 무엇인가? : 당첨 결과 정보 (6개의 숫자)
+- 무엇인가? : 금액을 표현하는 일급 컬렉션
 - 역할
-    - 당첨 번호 비교
+    - 금액 유효성 보장 (0 이상)
+    - 금액 연산 (덧셈, 곱셈, 나눗셈)
+    - BigDecimal을 사용한 정확한 금액 계산
 
-## 당첨 등수 (Rank)
+## 구매 (Purchase)
 
-- 무엇인가? : 당첨 결과 유형 (몇 개의 번호 일치, 당첨금)
+- 무엇인가? : 로또 구매 정보를 담은 객체
+- 역할
+    - 구매한 로또 티켓 목록 관리
+    - 티켓 개수 조회
+    - 총 구매 금액 계산
+
+## 당첨 티켓 (WinningTicket)
+
+- 무엇인가? : 당첨 번호 6개와 보너스볼 1개를 담은 티켓
+- 역할
+    - 당첨 번호 6개 보관
+    - 보너스볼 보관
+    - 구매 티켓의 보너스볼 포함 여부 확인
 
-## 로또 결과 (LottoResult)
+## 로또 게임 (LottoGame)
 
-- 무엇인가? : 어떤 Rank에 해당되는지 정보
+- 무엇인가? : 당첨 번호와 구매한 티켓들을 비교하여 결과를 생성하는 객체
+- 역할
+    - 당첨 번호 보관
+    - 구매한 티켓들의 당첨 결과 계산
+    - 게임 결과 생성
 
-## 로또 게임 결과 (Result)
+## 당첨 등수 (Rank)
 
-- 무엇인가? : 전체 로또 구매 결과 (당첨 통계, 수익률)을 나타내는 객체
+- 무엇인가? : 당첨 결과 유형 (몇 개의 번호 일치, 당첨금)
 - 역할
-    - 당첨 통계와 수익률을 포함하는 객체
+    - 일치 개수와 보너스볼 여부에 따른 등수 판정
+    - 등수별 당첨금 관리
+    - 5개 일치 시 보너스볼로 2등/3등 구분
 
-### 당첨 통계 Statistics
+## 로또 게임 결과 (GameResult)
 
-- 일치하는 번호 갯수, 몇 개
+- 무엇인가? : 전체 로또 구매 결과 (당첨 통계, 수익률)를 나타내는 객체
+- 역할
+    - 등수별 당첨 통계 관리
+    - 수익률 계산 (당첨 금액 / 구입 금액)
+    - 손익 판정 (기준: 1.0)
 
-### 수익률 ProfitRate
 
-- 수익률 = 당첨 금액 / 구입 금액 * 100
 
 

src/main/java/lotto/domain/game/LottoGame.java

@@ -1,29 +1,23 @@
 package lotto.domain.game;
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.List;
 import lotto.domain.lotto.LottoTicket;
-import lotto.domain.lotto.Money;
-import lotto.domain.result.GameResult;
+import lotto.domain.lotto.LottoTickets;
 import lotto.domain.lotto.Purchase;
+import lotto.domain.lotto.WinningTicket;
+import lotto.domain.result.GameResult;
 
 public class LottoGame {
 
-  private final LottoTicket winningTicket;
+  private final WinningTicket winningTicket;
 
-  public LottoGame(LottoTicket winningTicket) {
+  public LottoGame(WinningTicket winningTicket) {
     this.winningTicket = winningTicket;
   }
 
   public GameResult check(Purchase purchase) {
-    Money winningPrize = new Money(0);
-    Map<Rank, Integer> ranks = new HashMap<>();
-    for (LottoTicket ticket : purchase.getTickets()) {
-      Rank rank = Rank.valueOf(winningTicket.countMatchingNumbers(ticket));
-      ranks.compute(rank, (k, v) -> v == null ? 1 : v + 1);
-      winningPrize = winningPrize.add(rank.getPrize());
-    }
-
-    return new GameResult(ranks, winningPrize, purchase.getPurchaseAmount());
+    LottoTickets tickets = purchase.getTickets();
+    return tickets.updateRank(winningTicket);
   }
+
 }

src/main/java/lotto/domain/game/LottoMachine.java

@@ -1,9 +1,6 @@
 package lotto.domain.game;
 
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
-import lotto.domain.lotto.LottoTicket;
+import lotto.domain.lotto.LottoTickets;
 import lotto.domain.lotto.Money;
 import lotto.domain.lotto.Purchase;
 
@@ -22,19 +19,15 @@ public LottoMachine(Money lottoTicketPrice) {
   }
 
   public Purchase purchase(Money money) {
-    return new Purchase(money, generateTickets(calculate(money)));
+    return new Purchase(lottoTicketPrice, generateTickets(calculate(money)));
   }
 
   private int calculate(Money money) {
     return money.divideForCount(lottoTicketPrice);
   }
 
-  List<LottoTicket> generateTickets(int cnt) {
-    List<LottoTicket> tickets = new ArrayList<>();
-    for (int i = 0; i < cnt; i++) {
-      tickets.add(LottoTicket.of(Random.generate()));
-    }
-    return tickets;
+  LottoTickets generateTickets(int cnt) {
+    return new LottoTickets(cnt);
   }
 
 }

src/main/java/lotto/domain/game/Random.java

@@ -13,6 +13,7 @@ public class Random {
   private static List<Integer> numbers = IntStream.rangeClosed(MIN, MAX)
       .boxed()
       .collect(Collectors.toList());
+
   public static List<LottoNumber> generate() {
     Collections.shuffle(numbers);
     return numbers.subList(0, LOTTO_NUMBER_COUNT).stream()

src/main/java/lotto/domain/game/Rank.java

@@ -1,38 +1,57 @@
 package lotto.domain.game;
 
-import lotto.domain.lotto.Money;
+import java.util.Arrays;
 
 public enum Rank {
 
   FIRST(2_000_000_000, 6),
-  SECOND(1_500_000, 5),
-  THIRD(50_000, 4),
-  FOURTH(5000, 3),
+  SECOND(30_000_000, 5, true),
+  THIRD(1_500_000, 5),
+  FOURTH(50_000, 4),
+  FIFTH(5000, 3),
   NONE(0, -1);
 
   private final int prize;
   private final int matched;
+  private final boolean bonusMatched;
 
   Rank(int prize, int matched) {
+    this(prize, matched, false);
+  }
+
+  Rank(int prize, int matched, boolean bonusMatched) {
     this.prize = prize;
     this.matched = matched;
+    this.bonusMatched = bonusMatched;
   }
 
-  public static Rank valueOf(int matched) {
-    for (Rank rank : values()) {
-      if (rank.matched == matched) {
-        return rank;
-      }
-    }
-    return NONE;
+  public static Rank valueOf(int matched, boolean bonusMatched) {
+    return Arrays.stream(values())
+        .filter(x -> isMatch(x, matched, bonusMatched))
+        .findFirst()
+        .orElse(NONE);
+  }
+
+  public int getPrize() {
+    return prize;
   }
 
-  public Money getPrize() {
-    return new Money(this.prize);
+  private static boolean isMatch(Rank rank, int matched,
+      boolean bonusMatched) {
+    if (rank.matched != matched) {
+      return false;
+    }
+    if (matched != 5) {
+      return true;
+    }
+    return rank.bonusMatched == bonusMatched;
   }
 
   @Override
   public String toString() {
+    if (this == SECOND) {
+      return this.matched + "개 일치, 보너스 볼 일치 (" + this.prize + "원)";
+    }
     return this.matched + "개 일치 (" + this.prize + "원)";
   }
 }

src/main/java/lotto/domain/lotto/LottoNumber.java

@@ -5,6 +5,7 @@
 import java.util.Objects;
 
 public class LottoNumber {
+
   private static final Map<Integer, LottoNumber> CACHE = new HashMap<>();
 
   static {
@@ -19,7 +20,7 @@ private LottoNumber(int value) {
     this.value = value;
   }
 
-  public static LottoNumber of(int value){
+  public static LottoNumber of(int value) {
     validate(value);
     return CACHE.get(value);
   }

src/main/java/lotto/domain/lotto/LottoTicket.java

@@ -3,43 +3,32 @@
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.stream.Collectors;
-import lotto.domain.game.LottoMachine;
-import lotto.domain.game.Rank;
 
 public class LottoTicket {
+
   private static final int LOTTO_CNT = 6;
 
   private final List<LottoNumber> numbers;
 
-  private LottoTicket(List<LottoNumber> numbers) {
-    validate(numbers);
-    this.numbers = List.copyOf(numbers);
+  public LottoTicket(String numbers) {
+    this(convert(parse(numbers)));
   }
 
-  public static LottoTicket of(List<LottoNumber> numbers) {
-    return new LottoTicket(numbers);
+  public LottoTicket (Integer... numbers) {
+    this(convert(List.of(numbers)));
   }
 
-  public static LottoTicket from(String numbers) {
-    return new LottoTicket(convert(parse(numbers)));
-  }
-
-  public static LottoTicket of(Integer... numbers) {
-    return new LottoTicket(convert(List.of(numbers)));
+  public LottoTicket(List<LottoNumber> numbers) {
+    validate(numbers);
+    this.numbers = List.copyOf(numbers);
   }
 
   private static List<Integer> parse(String numbers) {
     return Arrays.stream(numbers.split(", "))
         .map(Integer::parseInt).toList();
   }
 
-  private static List<LottoNumber> convert(Integer... numbers) {
-    return Arrays.stream(numbers)
-        .map(LottoNumber::of)
-        .collect(Collectors.toList());
-  }
 
   private static List<LottoNumber> convert(List<Integer> numbers) {
     return numbers.stream()
@@ -53,15 +42,19 @@ private void validate(List<LottoNumber> numbers) {
     }
   }
 
-  public int countMatchingNumbers(LottoTicket winningNumbers) {
-    Set<LottoNumber> winnings = new HashSet<>(winningNumbers.numbers);
-    return (int) numbers.stream()
-        .filter(winnings::contains)
+  public int matchCount(LottoTicket ticket) {
+    return (int) this.numbers.stream()
+        .filter(ticket::contains)
         .count();
   }
 
+  public boolean contains(LottoNumber number) {
+    return this.numbers.contains(number);
+  }
+
   @Override
   public String toString() {
     return numbers.toString();
   }
+
 }