Apply feedback

src/main/java/racingcar/Application.java

@@ -0,0 +1,32 @@
+package racingcar;
+
+import java.util.Scanner;
+
+import racingcar.domain.Cars;
+import racingcar.domain.RacingGame;
+import racingcar.domain.RandomMoveStrategy;
+import racingcar.view.RacingView;
+
+public class Application {
+	public static void main(String[] args) {
+		RacingView racingView = new RacingView();
+
+		Scanner scanner = new Scanner(System.in);
+
+		try {
+			String[] names = racingView.inputNames(scanner);
+			Cars cars = new Cars(names);
+			int trialCount = racingView.inputTrialCount(scanner);
+
+			RacingGame racingGame = new RacingGame(cars, trialCount, new RandomMoveStrategy());
+
+			while(!racingGame.isEnd()) {
+				System.out.println(racingView.printRace(racingGame.race()));
+			}
+
+			System.out.println(racingView.printWinners(racingGame.getWinners()));
+		}catch(Exception e) {
+			System.out.println(e.getMessage());
+		}
+	}
+}

src/main/java/racingcar/domain/Car.java

@@ -0,0 +1,40 @@
+	package racingcar.domain;
+
+	public class Car {
+		private final String name;
+		private final Position position;
+		public Car(String name) {
+			this(name, 0);
+		}
+
+		public Car(String name, int position) {
+			if(name.length() == 0 || name.isEmpty()) {
+				throw new IllegalArgumentException("차 이름은 빈값을 넣을 수 없습니다.");
+			}
+
+			if(name.length() > 5) {
+				throw new IllegalArgumentException("차 이름의 길이를 5자를 초과할 수 없습니다.");
+			}
+
+			this.name = name;
+			this.position = new Position(position);
+		}
+
+		public void move(MoveStrategy moveStrategy) {
+			if(moveStrategy.movable()) {
+				position.add();
+			}
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public Position getPosition() {
+			return this.position;
+		}
+
+		public int getDistance() {
+			return position.getPosition();
+		}
+	}

src/main/java/racingcar/domain/Cars.java

@@ -0,0 +1,45 @@
+package racingcar.domain;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Cars {
+	private final List<Car> cars;
+
+	public Cars(List<Car> cars) {
+		this.cars = cars;
+	}
+
+	public Cars(String[] names) {
+		cars = Arrays.stream(names)
+			.map(Car::new)
+			.collect(Collectors.toList());
+	}
+
+	public Cars findWinners() {
+		Position maxPosition = getMaxPosition();
+
+		return new Cars(
+			cars.stream()
+			.filter(car -> car.getPosition().equals(maxPosition))
+			.collect(Collectors.toList())
+		);
+	}
+
+	public Position getMaxPosition() {
+
+		return cars.stream().map(Car::getPosition).max(
+			Comparator.comparingInt(Position::getPosition)
+		).orElse(new Position(0));
+	}
+
+	public List<Car> getCars() {
+		return cars;
+	}
+
+	public void moveAll(MoveStrategy moveStrategy) {
+		cars.forEach(car -> car.move(moveStrategy));
+	}
+}

src/main/java/racingcar/domain/MoveStrategy.java

@@ -0,0 +1,6 @@
+package racingcar.domain;
+
+@FunctionalInterface
+public interface MoveStrategy {
+	boolean movable();
+}

src/main/java/racingcar/domain/Position.java

@@ -0,0 +1,39 @@
+package racingcar.domain;
+
+import java.util.Objects;
+
+public class Position {
+	private int position;
+
+	public Position(int position) {
+		if(position < 0) {
+			throw new IllegalArgumentException("position은 0보다 적을 수 없습니다.");
+		}
+		this.position = position;
+	}
+
+	public void add() {
+		position++;
+	}
+
+	public int getPosition() {
+		return position;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o)
+			return true;
+		if (o == null || getClass() != o.getClass())
+			return false;
+		Position position1 = (Position)o;
+		return position == position1.position;
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(position);
+	}
+
+
+}

src/main/java/racingcar/domain/RacingGame.java

@@ -0,0 +1,39 @@
+package racingcar.domain;
+
+import racingcar.domain.Cars;
+import racingcar.domain.MoveStrategy;
+
+public class RacingGame {
+	private final Cars cars;
+	private final MoveStrategy moveStrategy;
+	private int trialCount;
+
+	public RacingGame(Cars cars, int trialCount, MoveStrategy moveStrategy) {
+		if(trialCount < 1) {
+			throw new IllegalArgumentException("시도할 횟수는 1이상이어야 합니다.");
+		}
+
+		this.cars = cars;
+		this.trialCount = trialCount;
+		this.moveStrategy = moveStrategy;
+	}
+
+	public boolean isEnd() {
+		return trialCount == 0;
+	}
+
+	public Cars race() {
+		if(trialCount == 0) {
+			return cars;
+		}
+
+		trialCount--;
+		cars.moveAll(moveStrategy);
+		return cars;
+	}
+
+	public Cars getWinners() {
+		return cars.findWinners();
+	}
+
+}

src/main/java/racingcar/domain/RandomMoveStrategy.java

@@ -0,0 +1,18 @@
+package racingcar.domain;
+
+import java.util.Random;
+
+public class RandomMoveStrategy implements MoveStrategy{
+	private static final int FORWARD_NUM = 4;
+	private static final int MAX_BOUND = 10;
+	private static final Random RANDOM = new Random();
+
+	@Override
+	public boolean movable() {
+		return getRandomNo() >= FORWARD_NUM;
+	}
+
+	private int getRandomNo() {
+		return RANDOM.nextInt(MAX_BOUND);
+	}
+}

src/main/java/racingcar/view/RacingView.java

@@ -0,0 +1,44 @@
+package racingcar.view;
+
+import java.util.Scanner;
+import java.util.stream.Collectors;
+
+import racingcar.domain.Car;
+import racingcar.domain.Cars;
+
+public class RacingView {
+
+	public String printRace(Cars cars) {
+
+		return 	cars.getCars()
+			.stream()
+			.map(RacingView::renderCarPosition)
+			.collect(Collectors.joining("\n"))
+			+ "\n";
+	}
+
+	private static String renderCarPosition(Car car) {
+		return car.getName() + " : " + "-".repeat(car.getDistance() + 1);
+	}
+
+	public String[] inputNames(Scanner scanner) {
+		System.out.println("경주할 자동차 이름을 입력하세요(이름은 쉼표(,)를 기준으로 구분).");
+
+		return scanner.nextLine().trim().split(",");
+	}
+
+	public int inputTrialCount(Scanner scanner) {
+		System.out.println("시도할 회수는 몇회인가요?");
+
+		return Integer.parseInt(scanner.nextLine());
+	}
+
+	public String printWinners(Cars cars) {
+		Cars winners = cars.findWinners();
+		String winnerNames = winners.getCars().stream().map(Car::getName).collect(Collectors.joining(", "));
+
+		return winnerNames + "가 최종 우승했습니다.";
+	}
+
+
+}

src/main/java/study/StringAddCalculator.java

@@ -0,0 +1,45 @@
+package study;
+
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import jdk.nashorn.internal.runtime.regexp.joni.Regex;
+
+public class StringAddCalculator {
+	private final static String BASIC_DELIMITER = ",|:";
+
+	public int splitAndSum(String str) {
+		if(isNullOrEmpty(str)) {
+			return 0;
+		}
+
+		String delimiter = getDelimiter(str);
+		if(!delimiter.equals(BASIC_DELIMITER)) {
+			str = str.substring(4);
+		}
+
+		return Arrays.stream(str.split(delimiter))
+			.mapToInt((num) -> {
+				if(num.matches("\\d*")){
+					return Integer.parseInt(num);
+				}
+				throw new RuntimeException();
+			}).sum();
+	}
+
+	public boolean isNullOrEmpty(String str) {
+		return str == null || str.isEmpty();
+	}
+
+	public String getDelimiter(String str) {
+		Matcher m = Pattern.compile("//(.)\n(.*)").matcher(str);
+
+		if (m.find()) {
+			return m.group(1) + "|" + BASIC_DELIMITER;
+		}
+
+		return BASIC_DELIMITER;
+	}
+
+}

src/test/java/racingcar/domain/CarTest.java

@@ -0,0 +1,34 @@
+package racingcar.domain;
+
+import static org.assertj.core.api.AssertionsForClassTypes.*;
+
+import org.junit.jupiter.api.Test;
+
+public class CarTest {
+	@Test
+	void create() {
+		assertThatThrownBy(() -> {
+			new Car("abcdef");
+		}).isInstanceOf(IllegalArgumentException.class);
+
+		assertThatThrownBy(() -> {
+			new Car("");
+		}).isInstanceOf(IllegalArgumentException.class);
+	}
+
+	@Test
+	void move() {
+		Car car = new Car("ws");
+		car.move(() -> true);
+
+		assertThat(car.getPosition()).isEqualTo(new Position(1));
+	}
+
+	@Test
+	void notMove() {
+		Car car = new Car("ws");
+		car.move(() -> false);
+
+		assertThat(car.getPosition()).isEqualTo(new Position(0));
+	}
+}