[4기 - 강병곤] 1~2주차 과제 : 계산기 구현 미션 제출합니다.

build.gradle

@@ -13,8 +13,8 @@ repositories {
 
 dependencies {
     testImplementation platform('org.junit:junit-bom:5.9.1')
-    testImplementation 'org.junit.jupiter:junit-jupiter'
-    testImplementation 'org.assertj:assertj-core:3.22.0'
+    testImplementation 'org.junit.jupiter:junit-jupiter:1.9.1'
+    testImplementation 'org.assertj:assertj-core:3.24.1'
 }
 
 test {

src/main/java/calcproject/Main.java

@@ -1,31 +1,27 @@
 package calcproject;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Scanner;
-
+import calcproject.di.container.CalcManagerDependencyInjectionContainer;
 import calcproject.engine.CalcExpressionTokenizer;
 import calcproject.engine.Calculator;
-import calcproject.models.CalcResultRecordModel;
-import calcproject.repository.CalcResultRecordRepository;
-import calcproject.repository.MemoryCalcResultRecordRepository;
+import calcproject.factory.CalcManagerViewFactory;
+import calcproject.factory.CalcResultRecordRepositoryFactory;
+import calcproject.factory.ConsoleViewCalcManagerViewFactory;
+import calcproject.factory.InMemoryCalcResultRecordRepositoryFacotry;
 import calcproject.service.CalcManager;
-import calcproject.view.console.CalcConsoleView;
 
 public class Main {
 	public static void main(String[] args) {
-		Map<Integer, CalcResultRecordModel> calcMap = new HashMap<>();
-		int startIdx = 0;
-		CalcResultRecordRepository calcResultRecordRepository =
-			new MemoryCalcResultRecordRepository(calcMap, startIdx);
-		Scanner scanner = new Scanner(System.in);
-		CalcConsoleView calcConsoleView = new CalcConsoleView(scanner);
 		CalcExpressionTokenizer calcExpressionTokenizer = new CalcExpressionTokenizer();
 		Calculator calculator = new Calculator(calcExpressionTokenizer);
 
-		CalcManager calcManager = new CalcManager(calcResultRecordRepository, calcConsoleView, calcConsoleView,
-			calculator);
+		CalcManagerViewFactory calcManagerViewFactory = new ConsoleViewCalcManagerViewFactory();
+		CalcResultRecordRepositoryFactory calcResultRecordRepositoryFactory = new InMemoryCalcResultRecordRepositoryFacotry();
+
+		CalcManagerDependencyInjectionContainer calcManagerDependencyInjectionContainer =
+			new CalcManagerDependencyInjectionContainer(calcResultRecordRepositoryFactory, calcManagerViewFactory,
+				calculator);
 
+		CalcManager calcManager = calcManagerDependencyInjectionContainer.createCalcManager();
 		calcManager.startCalcManager();
 	}
 }

src/main/java/calcproject/di/container/CalcManagerDependencyInjectionContainer.java

@@ -0,0 +1,46 @@
+package calcproject.di.container;
+
+import calcproject.engine.Calculator;
+import calcproject.factory.CalcManagerViewFactory;
+import calcproject.factory.CalcResultRecordRepositoryFactory;
+import calcproject.repository.CalcResultRecordRepository;
+import calcproject.service.CalcManager;
+import calcproject.view.CalcInput;
+import calcproject.view.CalcOutput;
+
+public class CalcManagerDependencyInjectionContainer {
+
+	private CalcResultRecordRepositoryFactory calcResultRecordRepositoryFactory;
+
+	private CalcManagerViewFactory calcManagerViewFactory;
+
+	private Calculator calculator;
+
+	public CalcManagerDependencyInjectionContainer(
+		CalcResultRecordRepositoryFactory calcResultRecordRepositoryFactory,
+		CalcManagerViewFactory calcManagerViewFactory, Calculator calculator) {
+		this.calcResultRecordRepositoryFactory = calcResultRecordRepositoryFactory;
+		this.calcManagerViewFactory = calcManagerViewFactory;
+		this.calculator = calculator;
+	}
+
+	public CalcManager createCalcManager() {
+		CalcResultRecordRepository calcResultRecordRepository =
+			calcResultRecordRepositoryFactory.createCalcResultRecordRepository();
+
+		CalcInput calcInput =
+			calcManagerViewFactory.createCalcInput();
+
+		CalcOutput calcOutput =
+			calcManagerViewFactory.createCalcOutput();
+
+		CalcManager calcManager = new CalcManager(
+			calcResultRecordRepository,
+			calcInput,
+			calcOutput,
+			this.calculator
+		);
+
+		return calcManager;
+	}
+}

src/main/java/calcproject/engine/CalcExpressionTokenizer.java

@@ -1,9 +1,36 @@
 package calcproject.engine;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class CalcExpressionTokenizer {
 	public List<String> tokenizeExpression(String expression) {
-		return null;
+		List<String> tokens = new ArrayList<>();
+		StringBuilder sb = new StringBuilder();
+
+		for (int i = 0; i < expression.length(); i++) {
+			char ch = expression.charAt(i);
+
+			if (ch == ' ') {
+				continue;
+			}
+
+			if (Character.isDigit(ch)) {
+				sb.append(ch);
+			} else {
+				String numberString = sb.toString();
+				tokens.add(numberString);
+				sb.setLength(0);
+
+				tokens.add(Character.toString(ch));
+			}
+		}
+
+		if (sb.length() > 0) {
+			String numberString = sb.toString();
+			tokens.add(numberString);
+		}
+
+		return tokens;
 	}
 }

src/main/java/calcproject/engine/Calculable.java

@@ -0,0 +1,5 @@
+package calcproject.engine;
+
+public interface Calculable {
+	public double calculate(double num1, double num2);
+}

src/main/java/calcproject/engine/Calculator.java

@@ -1,6 +1,8 @@
 package calcproject.engine;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Stack;
 
 public class Calculator {
 	private CalcExpressionTokenizer calcExpressionTokenizer;
@@ -9,8 +11,75 @@ public Calculator(CalcExpressionTokenizer calcExpressionTokenizer) {
 		this.calcExpressionTokenizer = calcExpressionTokenizer;
 	}
 
+	private boolean isNumber(String token) {
+		for (int i = 0; i < token.length(); i++) {
+			if (!Character.isDigit(token.charAt(i)))
+				return false;
+		}
+		return true;
+	}
+
+	public List<String> tokensToPostfixNotation(List<String> tokens) {
+		Stack<String> stack = new Stack<>();
+		List<String> postFixNotationTokens = new ArrayList<>();
+		for (String currentToken : tokens) {
+			if (isNumber(currentToken)) {
+				postFixNotationTokens.add(currentToken);
+				continue;
+			}
+
+			while (!stack.empty()) {
+				Operator currentOperator = Operator.opValueOf(currentToken);
+				Operator stackPeekOPerator = Operator.opValueOf(stack.peek());
+
+				if (stackPeekOPerator == Operator.UnSupportedOp) {
+					return null;
+				}
+
+				if (currentOperator.getPriority() > stackPeekOPerator.getPriority()) {
+					break;
+				}
+
+				postFixNotationTokens.add(stack.pop());
+			}
+
+			stack.add(currentToken);
+		}
+
+		while (!stack.empty()) {
+			postFixNotationTokens.add(stack.pop());
+		}
+
+		return postFixNotationTokens;
+	}
+
+	public double calculatePostfixNotation(List<String> postFixNotationTokens) {
+		Stack<Double> stack = new Stack<>();
+
+		for (int i = 0; i < postFixNotationTokens.size(); i++) {
+			String token = postFixNotationTokens.get(i);
+
+			if (isNumber(token)) {
+				double num = Double.valueOf(token);
+				stack.push(num);
+			} else {
+				Operator operator = Operator.opValueOf(token);
+
+				double operand2 = stack.pop();
+				double operand1 = stack.pop();
+				double result = operator.calculate(operand1, operand2);
+				stack.push(result);
+			}
+		}
+
+		return stack.pop();
+	}
+
 	public double calculateExpression(String expression) {
 		List<String> tokens = calcExpressionTokenizer.tokenizeExpression(expression);
-		return Double.NaN;
+		List<String> postfixTokens = tokensToPostfixNotation(tokens);
+		double calcResult = calculatePostfixNotation(tokens);
+
+		return calcResult;
 	}
 }

src/main/java/calcproject/engine/Operator.java

@@ -0,0 +1,44 @@
+package calcproject.engine;
+
+import java.util.Arrays;
+
+public enum Operator {
+	Plus("+", 0, (a, b) -> a + b),
+	Minus("-", 0, (a, b) -> a - b),
+	Multiply("*", 1, (a, b) -> a * b),
+	Divide("/", 1, (a, b) -> a / b),
+	UnSupportedOp("", -1, (a, b) -> Double.NaN);
+
+	private String operator;
+	private int priority;
+	private Calculable calculable;
+
+	Operator(String operator, int priority, Calculable calculable) {
+		this.operator = operator;
+		this.priority = priority;
+		this.calculable = calculable;
+	}
+
+	public static Operator opValueOf(String op) {
+		return Arrays.stream(values())
+			.filter(
+				value -> value
+					.getOperator()
+					.equals(op)
+			)
+			.findAny()
+			.orElse(Operator.UnSupportedOp);
+	}
+
+	public String getOperator() {
+		return this.operator;
+	}
+
+	public int getPriority() {
+		return this.priority;
+	}
+
+	public double calculate(double num1, double num2) {
+		return this.calculable.calculate(num1, num2);
+	}
+}

src/main/java/calcproject/engine/tokenaction/TokenAction.java

@@ -0,0 +1,5 @@
+package calcproject.engine.tokenaction;
+
+public interface TokenAction {
+	void perform();
+}

src/main/java/calcproject/factory/CalcManagerViewFactory.java

@@ -0,0 +1,10 @@
+package calcproject.factory;
+
+import calcproject.view.CalcInput;
+import calcproject.view.CalcOutput;
+
+public interface CalcManagerViewFactory {
+	public CalcInput createCalcInput();
+
+	public CalcOutput createCalcOutput();
+}

src/main/java/calcproject/factory/CalcResultRecordRepositoryFactory.java

@@ -0,0 +1,7 @@
+package calcproject.factory;
+
+import calcproject.repository.CalcResultRecordRepository;
+
+public interface CalcResultRecordRepositoryFactory {
+	public CalcResultRecordRepository createCalcResultRecordRepository();
+}

src/main/java/calcproject/factory/ConsoleViewCalcManagerViewFactory.java

@@ -0,0 +1,29 @@
+package calcproject.factory;
+
+import calcproject.view.CalcInput;
+import calcproject.view.CalcOutput;
+import calcproject.view.console.CalcConsoleView;
+
+public class ConsoleViewCalcManagerViewFactory implements CalcManagerViewFactory {
+
+	private CalcConsoleView calcConsoleView;
+
+	public ConsoleViewCalcManagerViewFactory() {
+		this.calcConsoleView = createCalcConsoleView();
+	}
+
+	public CalcConsoleView createCalcConsoleView() {
+		CalcConsoleView calcConsoleView = new CalcConsoleView();
+		return calcConsoleView;
+	}
+
+	@Override
+	public CalcInput createCalcInput() {
+		return this.calcConsoleView;
+	}
+
+	@Override
+	public CalcOutput createCalcOutput() {
+		return this.calcConsoleView;
+	}
+}

src/main/java/calcproject/factory/InMemoryCalcResultRecordRepositoryFacotry.java

@@ -0,0 +1,20 @@
+package calcproject.factory;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import calcproject.models.CalcResultRecordModel;
+import calcproject.repository.CalcResultRecordRepository;
+import calcproject.repository.MemoryCalcResultRecordRepository;
+
+public class InMemoryCalcResultRecordRepositoryFacotry implements CalcResultRecordRepositoryFactory {
+	@Override
+	public CalcResultRecordRepository createCalcResultRecordRepository() {
+		Map<Integer, CalcResultRecordModel> calcMap = new HashMap<>();
+		int startIdx = 0;
+		CalcResultRecordRepository calcResultRecordRepository =
+			new MemoryCalcResultRecordRepository(calcMap);
+
+		return calcResultRecordRepository;
+	}
+}

src/main/java/calcproject/repository/MemoryCalcResultRecordRepository.java

@@ -12,9 +12,9 @@ public class MemoryCalcResultRecordRepository implements CalcResultRecordReposit
 	private Map<Integer, CalcResultRecordModel> calcMap;
 	private int lastIdx;
 
-	public MemoryCalcResultRecordRepository(Map<Integer, CalcResultRecordModel> calcMap, int startIdx) {
+	public MemoryCalcResultRecordRepository(Map<Integer, CalcResultRecordModel> calcMap) {
 		this.calcMap = calcMap;
-		this.lastIdx = startIdx;
+		this.lastIdx = 0;
 	}
 
 	@Override
@@ -27,7 +27,7 @@ public void saveCalcResultRecord(CalcResultRecordModel calcResultRecord) {
 	public List<CalcResultRecordModel> loadCalcResultRecords() {
 		return this.calcMap.values()
 			.stream()
-			.sorted(Comparator.comparing(calcModel -> calcModel.getId()))
+			.sorted(Comparator.comparing(CalcResultRecordModel::getId))
 			.collect(Collectors.toList());
 	}
 }

src/main/java/calcproject/service/CalcManager.java

@@ -54,4 +54,4 @@ private void executeCmd(Command cmd) {
 				break;
 		}
 	}
-}
+}

src/main/java/calcproject/view/Command.java

@@ -15,7 +15,7 @@ public enum Command {
 
 	public static Command valueOf(int choiceNum) {
 		return Arrays.stream(values())
-			.filter(value -> value.equals(choiceNum))
+			.filter(value -> value.getCmdIdx() == choiceNum)
 			.findAny()
 			.orElse(CALCULATE.EXIT);
 	}