[2단계 - 로또(수동)] 연로그(권시연) 미션 제출합니다.

README.md

@@ -10,11 +10,16 @@
 - 로또 구입 금액을 입력하면 구입 금액에 해당하는 로또를 발급해야 한다.
 - 로또 1장의 가격은 1000원이다.
 
-## step1 요구사항
+## 요구사항
+> ⭐: step2에서 추가된 기능
 - [x] 로또 구입 금액
   - (e) 1000원 단위 외의 금액 불가
   - (e) 문자열 입력
   - 구매 로또 개수 구하기
+- [x] 수동 로또 ⭐
+  - (e) 구입한 금액보다 많이 구매했는지 확인
+  - 수동으로 구매할 로또 개수 입력
+  - 수동 로또 번호 입력
 - [x] 구매한 로또 개수 출력
 - [x] 로또 목록
   - 로또 생성
@@ -35,4 +40,4 @@
   - 숫자랑 위치 일치하는지 확인 
   - 보너스볼 확인
 - [x] 추첨 결과 출력
-  - 수익률 출력 (수익률 = 당첨 금액 /구입 금액)
+  - 수익률 출력 (수익률 = 당첨 금액 /구입 금액)

src/main/java/lotto/controller/LottoController.java

@@ -1,9 +1,12 @@
 package lotto.controller;
 
+import java.util.ArrayList;
+import java.util.List;
 import lotto.domain.LottoAmount;
 import lotto.domain.LottoNumber;
 import lotto.domain.LottoNumbers;
 import lotto.domain.LottoTicket;
+import lotto.domain.ManualLottoCount;
 import lotto.domain.WinningNumbers;
 import lotto.domain.WinningResult;
 import lotto.view.InputView;
@@ -13,7 +16,8 @@ public class LottoController {
     public void start() {
         LottoAmount amount = inputAmount();
 
-        LottoTicket lottoTicket = buyTickets(amount);
+        ManualLottoCount manualLottoCount = inputManualLottoCount(amount);
+        LottoTicket lottoTicket = buyTicket(amount, manualLottoCount);
 
         WinningNumbers winningNumbers = createWinningNumbers();
 
@@ -31,37 +35,68 @@ private LottoAmount inputAmount() {
         }
     }
 
-    private LottoTicket buyTickets(LottoAmount amount) {
-        int ticketCount = amount.calculateLottoCount();
-        OutputView.printTicketCount(ticketCount);
+    private ManualLottoCount inputManualLottoCount(LottoAmount amount) {
+        try {
+            return new ManualLottoCount(InputView.inputTryCount(), amount.calculateLottoCount());
+        } catch (IllegalArgumentException e) {
+            OutputView.printException(e);
+            return inputManualLottoCount(amount);
+        }
+    }
 
-        LottoTicket lottoTicket = new LottoTicket(ticketCount);
-        OutputView.printTicket(lottoTicket);
+    private LottoTicket buyTicket(LottoAmount amount, ManualLottoCount manualLottoCount) {
+        int manualTicketCount = manualLottoCount.getValue();
+        int autoTicketCount = amount.calculateLottoCount() - manualTicketCount;
+
+        LottoTicket lottoTicket = LottoTicket.createAutoLottoTicket(autoTicketCount);
+
+        if (manualTicketCount != 0) {
+            lottoTicket.addLottoTicket(buyManualTicket(manualLottoCount));
+        }
+
+        printTickets(manualTicketCount, autoTicketCount, lottoTicket);
         return lottoTicket;
     }
 
+    private LottoTicket buyManualTicket(ManualLottoCount manualLottoCount) {
+        List<LottoNumbers> manualTickets = new ArrayList<>();
+        int tryCount = manualLottoCount.getValue();
+
+        for (int i = tryCount; i > 0; i--) {
+            OutputView.printInputManualTicketSentence(i);
+            manualTickets.add(inputLottoNumbers());
+        }
+        return LottoTicket.createManualLottoTicket(manualTickets);
+    }
+
+    private void printTickets(int manualTryCount, int autoTryCount, LottoTicket lottoTicket) {
+        OutputView.printTicketCount(manualTryCount, autoTryCount);
+        OutputView.printTicket(lottoTicket);
+    }
+
     private WinningNumbers createWinningNumbers() {
-        LottoNumbers inputLottoNumbers = getInputLottoNumbers();
-        LottoNumber bonusNumber = getBonusNumber();
+        OutputView.printInputWinningTicketSentence();
+        LottoNumbers inputLottoNumbers = inputLottoNumbers();
+        LottoNumber bonusNumber = inputBonusNumber();
 
         return getWinningNumbers(inputLottoNumbers, bonusNumber);
     }
 
-    private LottoNumbers getInputLottoNumbers() {
+    private LottoNumbers inputLottoNumbers() {
         try {
-            return new LottoNumbers(InputView.inputWinningNumbers());
+            return new LottoNumbers(InputView.inputLottoNumbers());
         } catch (IllegalArgumentException e) {
             OutputView.printException(e);
-            return getInputLottoNumbers();
+            return inputLottoNumbers();
         }
     }
 
-    private LottoNumber getBonusNumber() {
+    private LottoNumber inputBonusNumber() {
         try {
             return LottoNumber.of(InputView.inputBonusBall());
         } catch (IllegalArgumentException e) {
             OutputView.printException(e);
-            return getBonusNumber();
+            return inputBonusNumber();
         }
     }
 
@@ -70,7 +105,7 @@ private WinningNumbers getWinningNumbers(LottoNumbers lottoNumbers, LottoNumber
             return new WinningNumbers(lottoNumbers, bonusNumber);
         } catch (IllegalArgumentException e) {
             OutputView.printException(e);
-            return getWinningNumbers(lottoNumbers, getBonusNumber());
+            return getWinningNumbers(lottoNumbers, inputBonusNumber());
         }
     }
 

src/main/java/lotto/domain/LottoAmount.java

@@ -4,8 +4,8 @@ public class LottoAmount {
     private static final int MIN_COST = 1000;
     private static final double DECIMAL = 1.0;
     private static final String NOT_NUMBER_ERROR = "금액은 숫자만 등록 가능합니다.";
-    private static final String NOT_NATURAL_NUMBER_ERROR = "금액은 " + MIN_COST + " 이상이어야 합니다.";
-    private static final String NOT_DIVISIBLE_NUMBER_ERROR = "금액은 " + MIN_COST + "단위여야 합니다.";
+    private static final String NOT_NATURAL_NUMBER_ERROR = String.format("금액은 %d 이상이어야 합니다.", MIN_COST);
+    private static final String NOT_DIVISIBLE_NUMBER_ERROR = String.format("금액은 %d 단위여야 합니다.", MIN_COST);
 
     private final int amount;
 

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

@@ -1,29 +1,25 @@
 package lotto.domain;
 
-import java.util.stream.IntStream;
+import java.util.HashMap;
+import java.util.Map;
 
 public class LottoNumber {
-    private static final int MIN = 1;
-    private static final int MAX = 45;
+    protected static final int MIN = 1;
+    protected static final int MAX = 45;
 
-    private static final String NUMBER_RANGE_ERROR = "로또 숫자는 " + MIN + " 이상 " + MAX + " 이하의 숫자만 가능합니다.";
+    private static final String NUMBER_RANGE_ERROR = String.format("로또 숫자는 %d 이상 %d 이하의 숫자만 가능합니다.", MIN, MAX);
 
-    private static final LottoNumber[] cacheLottoNumber = new LottoNumber[MAX + 1];
+    private static final Map<Integer, LottoNumber> cacheLottoNumber = new HashMap<>();
 
-    private final int number;
+    private final int value;
 
-    static {
-        IntStream.range(MIN, MAX + 1)
-                .forEach(i -> cacheLottoNumber[i] = new LottoNumber(i));
-    }
-
-    private LottoNumber(int number) {
-        this.number = number;
+    private LottoNumber(int value) {
+        this.value = value;
     }
 
     public static LottoNumber of(int number) {
         validateNumber(number);
-        return cacheLottoNumber[number];
+        return generateLottoNumber(number);
     }
 
     private static void validateNumber(int number) {
@@ -32,14 +28,42 @@ private static void validateNumber(int number) {
         }
     }
 
-    public int toInt() {
-        return number;
+    private static LottoNumber generateLottoNumber(int number) {
+        LottoNumber lottoNumber = cacheLottoNumber.get(number);
+        if (lottoNumber == null) {
+            lottoNumber = new LottoNumber(number);
+            cacheLottoNumber.put(number, lottoNumber);
+        }
+        return lottoNumber;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof LottoNumber)) {
+            return false;
+        }
+
+        LottoNumber that = (LottoNumber) o;
+
+        return value == that.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return value;
     }
 
     @Override
     public String toString() {
         return "LottoNumber{" +
-                "number=" + number +
+                "number=" + value +
                 '}';
     }
 }

src/main/java/lotto/domain/LottoNumbers.java

@@ -4,23 +4,19 @@
 import static java.util.stream.Collectors.toList;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
 public class LottoNumbers {
     private static final int LOTTO_COUNT = 6;
-    private static final int MIN_NUMBER = 1;
-    private static final int MAX_NUMBER = 45;
 
-    private static final String DELIMITER = ",";
     private static final String DUPLICATE_ERROR = "로또 개수는 중복이 불가능합니다.";
-    private static final String COUNT_ERROR = "로또 개수는 " + LOTTO_COUNT + "개로 제한됩니다.";
+    private static final String COUNT_ERROR = String.format("로또 개수는 %d개로 제한됩니다.", LOTTO_COUNT);
 
     private static final List<LottoNumber> candidateLottoNumbers = new ArrayList<>();
 
     static {
-        for (int i = MIN_NUMBER; i <= MAX_NUMBER; i++) {
+        for (int i = LottoNumber.MIN; i <= LottoNumber.MAX; i++) {
             candidateLottoNumbers.add(LottoNumber.of(i));
         }
     }
@@ -31,45 +27,44 @@ public LottoNumbers() {
         this.lottoNumbers = generateRandomLottoNumbers();
     }
 
-    public LottoNumbers(String input) {
-        String[] stringArr = input.split(DELIMITER);
-        validateLottoNumbers(stringArr);
-        this.lottoNumbers = convertStringArrToIntegerList(stringArr);
+    public LottoNumbers(List<Integer> numbers) {
+        validateLottoNumbers(numbers);
+        this.lottoNumbers = convertToLottoNumberList(numbers);
     }
 
     private List<LottoNumber> generateRandomLottoNumbers() {
         Collections.shuffle(candidateLottoNumbers);
         return List.copyOf(candidateLottoNumbers.subList(0, LOTTO_COUNT));
     }
 
-    private void validateLottoNumbers(String[] stringArr) {
-        validateLottoCount(stringArr);
-        validateDuplicateCount(stringArr);
+    private void validateLottoNumbers(List<Integer> numbers) {
+        validateLottoCount(numbers);
+        validateDuplicateCount(numbers);
     }
 
-    private void validateLottoCount(String[] array) {
-        if (array.length != LOTTO_COUNT) {
+    private void validateLottoCount(List<Integer> numbers) {
+        if (numbers.size() != LOTTO_COUNT) {
             throw new IllegalArgumentException(COUNT_ERROR);
         }
     }
 
-    private void validateDuplicateCount(String[] arr) {
-        int distinctCount = calDistinctCountFromArray(arr);
+    private void validateDuplicateCount(List<Integer> numbers) {
+        int distinctCount = calDistinctCountFromArray(numbers);
 
-        if (arr.length != distinctCount) {
+        if (numbers.size() != distinctCount) {
             throw new IllegalArgumentException(DUPLICATE_ERROR);
         }
     }
 
-    private int calDistinctCountFromArray(String[] arr) {
-        return (int) Arrays.stream(arr)
+    private int calDistinctCountFromArray(List<Integer> numbers) {
+        return (int) numbers.stream()
                 .distinct()
                 .count();
     }
 
-    private List<LottoNumber> convertStringArrToIntegerList(String[] array) {
-        return Arrays.stream(array)
-                .map(string -> LottoNumber.of(Integer.parseInt(string)))
+    private List<LottoNumber> convertToLottoNumberList(List<Integer> numbers) {
+        return numbers.stream()
+                .map(LottoNumber::of)
                 .collect(collectingAndThen(toList(), Collections::unmodifiableList));
     }
 

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

@@ -9,27 +9,41 @@
 import java.util.Objects;
 
 public class LottoTicket {
-    private final List<LottoNumbers> lottoTickets = new ArrayList<>();
+    private final List<LottoNumbers> lottoTicket;
 
-    public LottoTicket(int count) {
-        generateTickets(count);
+    private LottoTicket(final List<LottoNumbers> lottoTicket) {
+        this.lottoTicket = lottoTicket;
     }
 
-    private void generateTickets(int count) {
+    public static LottoTicket createAutoLottoTicket(int count) {
+        return new LottoTicket(generateTickets(count));
+    }
+
+    private static List<LottoNumbers> generateTickets(int count) {
+        List<LottoNumbers> lottoTicket = new ArrayList<>();
         for (int i = 0; i < count; i++) {
-            lottoTickets.add(new LottoNumbers());
+            lottoTicket.add(new LottoNumbers());
         }
+        return lottoTicket;
+    }
+
+    public static LottoTicket createManualLottoTicket(List<LottoNumbers> lottoTicket) {
+        return new LottoTicket(lottoTicket);
     }
 
-    public List<LottoNumbers> getLottoTickets() {
-        return Collections.unmodifiableList(lottoTickets);
+    public List<LottoNumbers> getLottoTicket() {
+        return Collections.unmodifiableList(lottoTicket);
     }
 
     public WinningResult calculateWinningStatistic(WinningNumbers winningNumbers) {
-        List<Ranking> rankings = lottoTickets.stream()
+        List<Ranking> rankings = lottoTicket.stream()
                 .map(winningNumbers::calculateRanking)
                 .filter(Objects::nonNull)
                 .collect(collectingAndThen(toList(), Collections::unmodifiableList));
         return new WinningResult(rankings);
     }
+
+    public void addLottoTicket(LottoTicket otherLottoTicket) {
+        lottoTicket.addAll(otherLottoTicket.getLottoTicket());
+    }
 }