[우테코 5기] <3주차> 'java-lotto' 회고

<우아한 테크코스 5기 프리코스 진행사항 - 3주차>

3주차 과제도 2주차 과제와 마찬가지로 하나의 주제를 가지고 기능별로 구현을 하는 알고리즘 문제였다.

요구사항은 크게 3가지로 나뉘어져있었다. 

1) 기능 요구 사항

2) 프로그래밍 요구 사항

3) 과제 진행 요구 사항

<백엔드 - Java> 기준으로 과제를 수행하였다.

---

<로또>

• 기능 요구 사항

- 로또 게임 기능을 구현해야 한다. 로또 게임은 아래와 같은 규칙으로 진행된다.

- 로또 번호의 숫자 범위는 1~45까지이다.
- 1개의 로또를 발행할 때 중복되지 않는 6개의 숫자를 뽑는다.
- 당첨 번호 추첨 시 중복되지 않는 숫자 6개와 보너스 번호 1개를 뽑는다.
- 당첨은 1등부터 5등까지 있다. 당첨 기준과 금액은 아래와 같다.
    - 1등: 6개 번호 일치 / 2,000,000,000원
    - 2등: 5개 번호 + 보너스 번호 일치 / 30,000,000원
    - 3등: 5개 번호 일치 / 1,500,000원
    - 4등: 4개 번호 일치 / 50,000원
    - 5등: 3개 번호 일치 / 5,000원

• 입출력 요구 사항

• 프로그래밍 요구 사항

• 구현과정

요구사항을 살펴보니 "indent(인덴트, 들여쓰기) depth를 3이 넘지 않도록 구현 (2까지만 허용)" 이 있었다.

함수를 분리하여 구현하는 것이 중요해보였고,

또 다른 요구사항인 "함수가 한가지 일만 하도록 최대한 작게 만들기" 또한 함수 분리 구현이 필수적인 것 같았다.

2주차와 마찬가지로 JUnit 5와 AssertJ 를 이용해 각 기능별로 단위 테스트를 진행해야했다.

또 어려웠던 점은 함수의 길이가 15라인이상 넘어가지 않도록 구현해야했는데

클래스의 분리를 더 세분화시켜야할 것 같았다.

요구사항에서 제공된 lotto 클래스의 기본구조는 2주차에서의 Init_game 클래스와 비슷해보였다. 

IllegalArgumentException을 발생시키는 부분이나, number.size가 넘치지 않도록 조건문을 달아주는 것 또한

숫자 야구 게임과 유사한 부분이 있었다. 

이번 프로젝트에서는 클래스를 더 세분화해야하기때문에 lotto 패키지 안에

다른 세부 패키지로 나누어서 관리해야할 것 같았다.

lotto 패키지 안에 기능을 구현할 domain과 예외처리를 할 exception, 화면에 보여지는 view 패키지로 나눌 수 있었다.

Application과 Gameplay는 lotto 패키지 내에서 다른 클래스들을 참조하여 실행할 수 있도록 설계하였다.

---

<Application.java>

package lotto;

public class Application {
    public static void main(String[] args) {
        // TODO: 프로그램 구현
        final Gameplay gameplay = Gameplay.create();
        gameplay.run();
    }
}

- Application.java에서 Gameplay를 진행하고 gameplay 클래스 안에서 게임이 실제 시작되는 로직을 구현하였다.

<Gameplay.java>

package lotto;

import lotto.domain.lotto.LottoFactory;
import lotto.domain.lotto.LottoGroup;
import lotto.domain.lotto.LottoMoney;
import lotto.domain.lotto.WinningLotto;
import lotto.domain.result.Result;
import lotto.domain.result.TicketCount;
import lotto.view.InputView;
import lotto.view.ResultView;

public class Gameplay {
    private Gameplay(){

    }

    public static Gameplay create() {
        return new Gameplay();
    }

    private static float getProfit(final float nowMoney, final float pastMoney) {
        return nowMoney / pastMoney;
    }

    public void run() {
        final LottoMoney lottoMoney = makeLottoMoney();
        final TicketCount count = makeLottoTicketCount(lottoMoney);
        final LottoGroup lottoTickets = makeLottos(count);
        ResultView.printLottoTickets(count, lottoTickets);

        final WinningLotto winningLotto = makeWinNums();

        final Result result = Result.of(lottoTickets, winningLotto);
        end(result, lottoMoney);
    }

    private LottoMoney makeLottoMoney() {
        return LottoMoney.from(
                InputView.inputMoney());
    }

    private TicketCount makeLottoTicketCount(final LottoMoney money) {
        return TicketCount.of(money.toLottoCount(),
                InputView.inputManualTicketCount());
    }

    private LottoGroup makeLottos(final TicketCount count) {
        return LottoFactory.createLottos(count,
                InputView.inputManualNums(count.ofManual()));
    }

    private WinningLotto makeWinNums() {
        return LottoFactory.createWinNums(InputView.inputWinLottoNums(), InputView.inputBonusNumber());
    }

    private void end(final Result result, final LottoMoney lottoMoney) {
        ResultView.printLottosResult(result);
        ResultView.printProfit(getProfit((float) result.getPrize(), (float) lottoMoney.get()));
    }
}

생성자를 만들고, create()를 통해 Gameplay를 재호출하도록 기본 골격을 만든다.

run()부분이 중요했는데, 로또금액인 lottoMoney와 TicketCount, LottoGroup 등을 참조하였다.

로또에 당첨되는 부분 또한 result를 통해 구현하였다.

makeLottoMoney()에서는 View 패키지의 InputView에서 참조할 수 있었다.

run부분에서는 전체적으로 생성과 게임을 진행시키는 Initialize 부분을 만들어냈다.

---

<domain> - <generator>

<NumsGenerator.java>

package lotto.domain.generator;

import lotto.domain.lotto.LottoNumber;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class NumsGenerator {
    private static final int START_INDEX = 0;
    private static final int END_INDEX = 6;

    public static List<LottoNumber> RandomNumber(){
        final List<LottoNumber> lottoNumbers = new ArrayList<>(LottoNumber.getCache().values());

        Collections.shuffle(lottoNumbers);
        return lottoNumbers.subList(START_INDEX, END_INDEX);
    }

    public static List<LottoNumber> generate(final List<Integer> lottoNums){
        return lottoNums.stream()
                .map(LottoNumber::getInstance)
                .sorted()
                .collect(Collectors.toList());
    }
}

- 시작 인덱스와 끝 인덱스를 final로 설정하고, static final 처럼 변하지 않는 전역변수를 설정할때는

대문자로 변수를 만드는 것이 좋다는 것을 새롭게 배울 수 있었다. (우테코 프리코스 깃허브 커뮤니티)

RandomNumber메서드로 로또 번호를 생성하고 Collections 클래스의 shuffle 메서드로 이 번호들을 무작위로 섞는다.

generator 메서드에서는 stream()을 이용해 기능을 세부적으로 접근하여 리스트로 만든다. 

---

<domain> - <lotto>

<Lotto.java>

package lotto.domain.lotto;

import lotto.exception.lotto.LottoNumDuplicatedException;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;

public class Lotto {
    private static final int SIZE = 6;
    final List<LottoNumber> numbers;

    public Lotto(List<LottoNumber> numbers) {
        validate(numbers);
        Collections.sort(numbers);
        this.numbers = List.copyOf(numbers);
    }

    private static void validate(List<LottoNumber> numbers) {
        Set<LottoNumber> setNumbers = new HashSet<>(numbers);

        if (numbers.size() != SIZE) {
            throw new IllegalArgumentException();
        }

        if (setNumbers.size() != numbers.size()){
            throw new LottoNumDuplicatedException(numbers);
        }
    }

    // TODO: 추가 기능 구현
    public static Lotto from(final List<LottoNumber> numbers){
        return new Lotto(numbers);
    }

    public int countSameNum(final WinningLotto winningLotto){
        return (int) numbers.stream()
                .filter(winningLotto::contains)
                .count();
    }
    public boolean contains(final LottoNumber lottoNumber) {
        return numbers.contains(lottoNumber);
    }
    public List<LottoNumber> get() {
        return List.copyOf(numbers);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Lotto lotto1 = (Lotto) o;
        return Objects.equals(numbers, lotto1.numbers);
    }

    @Override
    public int hashCode() {
        return Objects.hash(numbers);
    }

    @Override
    public String toString() {
        return "Lotto{" +
                "lotto=" + numbers +
                '}';
    }
}

- 로또의 속성을 관리하는 부분이며 6개의 번호를 받는 부분과 정렬하는 부분을 구현하였다.

로또 클래스에서는 6개의 번호 규격을 넘어갈 경우 IllegalArgumentException을 발생시키도록 하였다.

setNumbers를 HashSet으로 만들어 해시의 중복제거 특징을 활용하여 LottoNumDuplicatedException 예외처리 시

중복을 검사할 수 있도록 하였다.

countSameNum메서드로 winningLotto (맞춘개수)를 증가시킨다.

<lotto> - <lotto> - <LottoFactory.java> 에서는

보너스를 처리하고, 자동적으로 로또번호를 생성하도록 하였다.

<lotto> - <lotto> - <LottoGroup.java> 에서는

NullException을 발생시키는 부분, Lotto.java와 같이 equals를 처리하는 부분을 작성하였다.

<lotto> - <lotto> - <LottoMoney.java> 에서는

LottoMoneyLessException : 금액 예외처리와

LottoMoneyDivideException : Lotto 번호 나누는 예외처리를 구현하였다. 

<lotto> - <lotto> - <LottoNumber.java> 에서는

로또 번호의 범위를 지정하였다.

private static final int MIN = 1;
private static final int MAX = 45;

compareTo 를 통해 각 클래스에서 지정된 object와 기준 값을 비교할 수 있도록 하였다.

@Override
public int compareTo(LottoNumber o) {
    return java.lang.Integer.compare(value, o.get());
}

<lotto> - <lotto>

<WinningLotto.java>

package lotto.domain.lotto;

import lotto.exception.lotto.BonusNumDuplicatedException;

public class WinningLotto {
    private final Lotto lotto;
    private final LottoNumber bonusNumber;

    private WinningLotto(final Lotto lotto, final LottoNumber bonusNumber) {
        validate(lotto, bonusNumber);
        this.lotto = lotto;
        this.bonusNumber = bonusNumber;
    }

    public static WinningLotto of(final Lotto lotto, final LottoNumber bonusNumber) {
        return new WinningLotto(lotto, bonusNumber);
    }

    private static void validate(final Lotto lotto, final LottoNumber number) {
        if (lotto.contains(number)) {
            throw new BonusNumDuplicatedException(number.get());
        }
    }

    public boolean contains(final LottoNumber number) {
        return lotto.contains(number);
    }

    public LottoNumber getBonusNumber() {
        return bonusNumber;
    }
}

- 보너스 숫자를 관리하는 부분과 번호를 맞췄을때 다른 클래스를 참조할 수 있도록 다리 기능의 코드를 구현하였다.

---

<lotto> - <result>

<Rank.java>

package lotto.domain.result;

import java.util.Arrays;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.stream.Collectors;

public enum Rank {
    NONE(0, 0,
            (matchCount, isBonus) -> matchCount < 3),
    FIFTH(5000, 3,
            (matchCount, isBonus) -> matchCount == 3),
    FOURTH(50000, 4,
            (matchCount, isBonus) -> matchCount == 4),
    THIRD(1500000, 5,
            (matchCount, isBonus) -> matchCount == 5 && !isBonus),
    SECOND(30000000, 5,
            (matchCount, isBonus) -> matchCount == 5 && isBonus),
    FIRST(2000000000, 6,
            (matchCount, isBonus) -> matchCount == 6);

    private final int prize;
    private final int matchCount;
    private final BiPredicate<Integer, Boolean> condition;

    Rank(final int prize, final int matchCount, BiPredicate<Integer, Boolean> condition) {
        this.prize = prize;
        this.matchCount = matchCount;
        this.condition = condition;
    }

    public static Rank of(final int matchCount, final boolean isBonus) {
        return Arrays.stream(Rank.values())
                .filter(rank -> rank.condition.test(matchCount, isBonus))
                .findAny()
                .orElse(NONE);
    }

    public static List<Rank> getWithoutDefault() {
        return Arrays.stream(Rank.values())
                .filter(rank -> !rank.equals(NONE))
                .collect(Collectors.toList());
    }

    public int getPrize() {
        return prize;
    }

    public int getMatchCount() {
        return matchCount;
    }
}

- 아무것도 못맞췄을때와 어느정도 맞추었을때의 상금의 크기를 지정하였다. 

5위부터 금액이 매겨져 1위에서는 20억을 prize로 지정하였다.

<lotto> - <result>

<Result.java>

package lotto.domain.result;

import lotto.domain.lotto.Lotto;
import lotto.domain.lotto.LottoGroup;
import lotto.domain.lotto.WinningLotto;
import java.util.LinkedHashMap;

public class Result {
    private final LinkedHashMap<Rank, Integer> value = new LinkedHashMap<>();

    private Result(final LottoGroup lottos, final WinningLotto winningLotto) {
        for (Lotto lotto : lottos.get()) {
            Rank rank = Rank.of(lotto.countSameNum(winningLotto), lotto.contains(winningLotto.getBonusNumber()));
            add(rank);
        }
    }

    public static Result of(final LottoGroup lottos, final WinningLotto winningLotto) {
        return new Result(lottos, winningLotto);
    }

    private void add(final Rank rank) {
        value.merge(rank, 1, Integer::sum);
    }

    public long getPrize() {
        long prize = 0;
        for (Rank rank : value.keySet()) {
            prize += (long) rank.getPrize() * value.get(rank);
        }
        return prize;
    }

    public int getRankCount(final Rank rank) {
        return value.getOrDefault(rank, 0);
    }
}

Result에서는 전체적인 결과를 만들어내기 위해 rank를 merge하는 부분과

getPrize()로 상금을 계산하는 부분을 구현하였다.

<lotto> - <result> - <TicektCount.java> 에서는

로또를 몇장 사는지 받아와서 자동적으로 로또번호를 생성하는 다리 역할을 하도록 구현하였다.

---

<lotto> - <exception> 에서 위에 각 구현하였던 클래스 별로 발생할 수 있는 예외들을 작성해서 처리하도록 하였다.

크게 중복, 잘못된 패턴, 규격에 맞지않는 사이즈 관련 예외처리 등이 있으며, 

TicketCount를 처리하는 부분에서는 로또 장 수가 입력되지 않거나 너무 많게 입력되었을 경우의 처리를 담당하였다.

---

<lotto> - <view>

<InputView.java>

package lotto.view;

import lotto.exception.lotto.LottoNumWrongPatternException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class InputView {
    private static final String MONEY_INPUT_MESSAGE = "구입금액을 입력해 주세요.";
    private static final String LOTTO_NUMBER_INPUT_MESSAGE = System.lineSeparator() + "지난 주 당첨 번호를 입력해 주세요.";
    private static final String BONUS_INPUT_MESSAGE = "보너스 볼을 입력해 주세요.";
    private static final String MANUAL_TICKET_COUNT_MESSAGE = System.lineSeparator() + "수동으로 구매할 로또 수를 입력해 주세요.";
    private static final String MANUAL_TICKET_NUMBS_GROUP_MESSAGE = System.lineSeparator() + "수동으로 구매할 번호를 입력해 주세요.";

    private static final String REGEX = ",";
    private static final Pattern PATTERN = Pattern.compile("^[\\d]+,[\\d]+,[\\d]+,[\\d]+,[\\d]+,[\\d]+$");
    private static final Scanner SCANNER = new Scanner(System.in);

    public static int inputMoney() {
        System.out.println(MONEY_INPUT_MESSAGE);
        return inputNum();
    }

    public static int inputManualTicketCount() {
        System.out.println(MANUAL_TICKET_COUNT_MESSAGE);
        return inputNum();
    }

    public static int inputBonusNumber() {
        System.out.println(BONUS_INPUT_MESSAGE);
        return inputNum();
    }

    public static List<Integer> inputWinLottoNums() {
        System.out.println(LOTTO_NUMBER_INPUT_MESSAGE);
        return inputLottoNums();
    }

    public static List<List<Integer>> inputManualNums(final int repeatCount) {
        System.out.println(MANUAL_TICKET_NUMBS_GROUP_MESSAGE);
        List<List<Integer>> numsGroup = new ArrayList<>();
        for (int i = 0; i < repeatCount; i++) {
            numsGroup.add(inputLottoNums());
        }
        return numsGroup;
    }

    private static int inputNum() {
        int number = SCANNER.nextInt();
        SCANNER.nextLine();
        return number;
    }

    private static List<Integer> inputLottoNums() {
        final String lottoNumbers = SCANNER.nextLine();
        validateLottoNums(lottoNumbers);
        return separateNumbers(lottoNumbers);
    }

    private static List<Integer> separateNumbers(final String numbersText) {
        return Arrays.stream(numbersText.split(REGEX))
                .map(Integer::parseInt)
                .collect(Collectors.toList());
    }

    private static void validateLottoNums(final String rawLottoNumbers) {
        if (!PATTERN.matcher(rawLottoNumbers).matches()) {
            throw new LottoNumWrongPatternException(rawLottoNumbers);
        }
    }
}

- 전체적으로 게임 UI를 출력할 수 있도록 하였고, 입력을 받는 부분을 InputView.java에서 처리할 수 있도록 하였다.

새롭게 공부한 사실은

System.out.println( 문자열변수 );
>>

private static final String MONEY_INPUT_MESSAGE = "구입금액을 입력해 주세요.";

처럼 위에서 전역변수로 지정해주고, 그 문자열 변수에 따라 각 클래스에 넣어 처리하도록 하는 부분이

클래스 세분화에 있어서 중요한 부분이라고 생각하였다.

<lotto> - <view>

<ResultView.java>

package lotto.view;

import lotto.domain.lotto.Lotto;
import lotto.domain.lotto.LottoGroup;
import lotto.domain.lotto.LottoNumber;
import lotto.domain.result.Rank;
import lotto.domain.result.Result;
import lotto.domain.result.TicketCount;

public class ResultView {
    private static final String BUY_MESSAGE =
            System.lineSeparator() + "%d개를 구매했습니다." + System.lineSeparator();
    private static final String LOTTO_PREFIX = "[";
    private static final String LOTTO_ENDFIX = "]";
    private static final String SEPARATOR = ", ";
    private static final int DELETE_IDX = 2;
    private static final String RESULT_START_MESSAGE =
            System.lineSeparator() + "당첨 통계" + System.lineSeparator() + "---";
    private static final String RESULT_RANK_MESSAGE = "%d개 일치%s(%d원)- %d개" + System.lineSeparator();
    private static final String SAME_BONUS_MESSAGE = ", 보너스 볼 일치";
    private static final String PROFIT_MESSAGE =
            "총 수익률은 %.2f입니다." + System.lineSeparator();
    private static final String NO_MESSAGE = " 아니";

    public static void printLottoTickets(final TicketCount count, final LottoGroup lottoTickets) {
        System.out.printf(BUY_MESSAGE, count.ofManual(), count.ofAuto());
        for (Lotto lotto : lottoTickets.get()) {
            printLottoNumbers(lotto);
        }
    }

    private static void printLottoNumbers(final Lotto lotto) {
        StringBuilder result = new StringBuilder(LOTTO_PREFIX);
        for (LottoNumber lottoNumber : lotto.get()) {
            result.append(lottoNumber.get()).append(SEPARATOR);
        }
        result.delete(result.length() - DELETE_IDX, result.length()).append(LOTTO_ENDFIX);
        System.out.println(result);
    }

    public static void printLottosResult(final Result result) {
        System.out.println(RESULT_START_MESSAGE);
        for (Rank rank : Rank.getWithoutDefault()) {
            System.out.printf(RESULT_RANK_MESSAGE,
                    rank.getMatchCount(), printIfSecond(rank),
                    rank.getPrize(), result.getRankCount(rank));
        }
    }

    private static String printIfSecond(final Rank rank) {
        if (rank.equals(Rank.SECOND)) {
            return SAME_BONUS_MESSAGE;
        }
        return " ";
    }

    public static void printProfit(final float profit) {
        System.out.printf(PROFIT_MESSAGE,
                profit, printIfLoss(profit));
    }

    private static Object printIfLoss(final float profit) {
        if (profit >= 1) {
            return NO_MESSAGE;
        }
        return "";
    }
}

- 입력된 부분을 처리된 후 출력을 규격에 맞게 할 수 있는 부분과

전체적인 프로그램 진행상황을 화면에 보여질 수 있도록 하였다.

또한 최종적인 결과 출력과 입력했을 때마다 나올 수 있는 부분들을 구현해낼 수 있었다.

---

제출 결과로 모든 예제를 통과할 수 없었다. 확실히 주마다 난이도도 올라가고, 추가되는 요구사항도 많아

클래스를 한번 구현한 후에도 코드 리팩토링을 통해 계속 수정하는 부분이 많았다. 

이번에도 예제 테스트를 통과할 수 있도록 많은 리팩토링을 거쳤지만 과제 제출기간 내에 완벽히 구현해내지 못해서 

아쉬운 결과였다.

마지막 주차를 남겨두고 있는 가운데 다음 과제를 위해 더 공부하며 코드적으로 보강해야겠다고 생각했다.