main.java

/*
 * Main
 *
 * Ver. 1.0.0
 *
 * Free for using, without license
 *
 * Program which implements simple calculator based on Stack Model and
 * converting expression into postfix form.
 */

import java.util.Scanner;
import java.util.ArrayList;

/**
 * The Main class provides general functionality of the program.
 *
 * @author Artur Mukhutdinov
 * @version 1.0.0 15 December 2022
 */
final class OptionalProject {
 private OptionalProject() {
 }

 public static void main(String[] args) {
 Converter converter = new Converter();

 Scanner s = new Scanner(System.in);

 System.out.println("Please, write your expression separated by spaces! (Example: (a + b) - c * d):"
 + "\n" + "Expression in infix (normal) form: ");
 String expression = converter.convertInfixIntoPostfix(s.nextLine());
 System.out.println("Postfix form of your expression: " + expression);

 Calculator calculator = new Calculator();

 Stack<String> stack = new Stack<>();

 String[] separatedExpression = expression.split(" ");

 for (String elem : separatedExpression) {
 if (isSign(elem)) {
 Signs signType = Signs.parseSign(elem.charAt(0));
 makeOperation(signType, stack, calculator);
 continue;
 }

 pushOperandToStack(elem, stack);
 }

 System.out.println("Result of your expression: " + stack.getFirstFromTop());
 }

 private static boolean isSign(String elem) {
 return (elem.length() == 1 && Signs.parseSign(elem.charAt(0)) != null);
 }

 private static void makeOperation(Signs signType, Stack<String> stack, Calculator calculator) {
 switch (signType) {
 case PLUS -> {
 String result = calculator.addition(stack.getFirstFromTop(), stack.getSecondFromTop());
 stack.pop();
 stack.pop();
 stack.push(result);
 }
 case MINUS -> {
 String result = calculator.subtraction(stack.getSecondFromTop(), stack.getFirstFromTop());
 stack.pop();
 stack.pop();
 stack.push(result);
 }
 case MUL -> {
 String result = calculator.multiplication(stack.getFirstFromTop(), stack.getSecondFromTop());
 stack.pop();
 stack.pop();
 stack.push(result);
 }
 case DIV -> {
 String result = calculator.division(stack.getSecondFromTop(), stack.getFirstFromTop());
 stack.pop();
 stack.pop();
 stack.push(result);
 }
 default -> {
 }
 }
 }

 private static void pushOperandToStack(String operand, Stack<String> stack) {
 stack.push(operand);
 }
}

interface Calculations {

 String addition(String operand1, String operand2);

 String subtraction(String operand1, String operand2);

 String multiplication(String operand1, String operand2);

 String division(String operand1, String operand2);
}

class Calculator implements Calculations {
 /**
 * Method convert operands from string type of certain and make calculations.
 * After this method return a string representation of the result.
 * Result of this method - addition of two operands.
 *
 * @param operand1 string representation of operand 1.
 * @param operand2 string representation of operand 2.
 * @return string representation of the result.
 */
 @Override
 public String addition(String operand1, String operand2) {
 try {
 return String.valueOf(Double.parseDouble(operand1) + Double.parseDouble(operand2));
 } catch (Exception e) {
 System.out.println(e.getMessage());
 System.exit(0);
 }
 return "";
 }

 /**
 * Method convert operands from string type of certain and make calculations.
 * After this method return a string representation of the result.
 * Result of this method - subtraction of two operands.
 *
 * @param operand1 string representation of operand 1.
 * @param operand2 string representation of operand 2.
 * @return string representation of the result.
 */
 @Override
 public String subtraction(String operand1, String operand2) {
 try {
 return String.valueOf(Double.parseDouble(operand1) - Double.parseDouble(operand2));
 } catch (Exception e) {
 System.out.println(e.getMessage());
 System.exit(0);
 }
 return "";
 }

 /**
 * Method convert operands from string type of certain and make calculations.
 * After this method return a string representation of the result.
 * Result of this method - multiplication of two operands.
 *
 * @param operand1 string representation of operand 1.
 * @param operand2 string representation of operand 2.
 * @return string representation of the result.
 */
 @Override
 public String multiplication(String operand1, String operand2) {
 try {
 return String.valueOf(Double.parseDouble(operand1) * Double.parseDouble(operand2));
 } catch (Exception e) {
 System.out.println(e.getMessage());
 System.exit(0);
 }
 return "";
 }

 /**
 * Method convert operands from string type of certain and make calculations.
 * After this method return a string representation of the result.
 * Result of this method - division of two operands.
 *
 * @param operand1 string representation of operand 1.
 * @param operand2 string representation of operand 2.
 * @return string representation of the result.
 */
 @Override
 public String division(String operand1, String operand2) {
 try {
 return String.valueOf(Double.parseDouble(operand1) / Double.parseDouble(operand2));
 } catch (Exception e) {
 System.out.println(e.getMessage());
 System.exit(0);
 }
 return "";
 }
}

/**
 * Implementation of simple stack model according to canonical stack definition.
 *
 * @param <T> Data type which would be stored in the stack.
 */
class Stack<T> {
 /**
 * Variable which are implements stack itself.
 * Provide a functionality according to canonical stack model.
 */
 private final ArrayList<T> stack = new ArrayList<>();

 /**
 * Add object on the top of the stack.
 *
 * @param object added on the top of the stack.
 */
 public void push(T object) {
 stack.add(object);
 }

 /**
 * Remove object from the top of the stack.
 */
 public void pop() {
 stack.remove(this.depth() - 1);
 }

 /**
 * Return string representation of the stack array and clear stack overall.
 *
 * @return String representation of the stack.
 */
 public String uploadStackInString() {
 StringBuilder string = new StringBuilder();

 if (stack.size() == 0) return "";

 int i = 0;
 string.append(stack.get(i));

 for (i = 1; i < this.depth(); i++) {
 string.append(" ").append(stack.get(i));
 }

 stack.clear();

 return string.toString();
 }

 /**
 * Return string representation of the expression in the LAST GAINED BRACKETS and remove it from the stack.
 *
 * @return String representation of the expression in the LAST GAINED BRACKETS
 */
 public String uploadExpressionInParentsInString() {
 StringBuilder string = new StringBuilder();

 int startIndex = stack.lastIndexOf("(");
 int finishIndex = stack.indexOf(")");

 for (int i = startIndex + 1; i < finishIndex; i++) {
 if (i == startIndex + 1) {
 string.append(stack.get(i));
 continue;
 }

 string.append(" ").append(stack.get(i));
 }
 removeSubsequence(startIndex, finishIndex);

 return string.toString();
 }

 private void removeSubsequence(int start, int finish) {
 int length = finish - start + 1;

 if (length == stack.size()) {
 uploadStackInString();
 length = 0;
 }

 while (length > 0) {
 stack.remove(start);
 length--;
 }
 }

 /**
 * Method return a size of the stack.
 *
 * @return int value of stack size.
 */
 public int depth() {
 return stack.size();
 }

 /**
 * Method return first element of the stack.
 *
 * @return Object of T type from the top of the stack.
 */
 public T getFirstFromTop() {
 return stack.get(this.depth() - 1);
 }

 /**
 * Method return second element of the stack.
 *
 * @return Object of T type from the second place counting from the top of the stack.
 */
 public T getSecondFromTop() {
 return stack.get(this.depth() - 2);
 }
}

interface Conversions {
 /**
 * Function which implements simple translation from Infix --> Postfix form of expression notation.
 *
 * @param expression Expression given in string format.
 * @return Given expression, converted into postfix form, also in string format.
 */
 String convertInfixIntoPostfix(String expression);
}

/**
 * Class provides a several conversions from one type to another.
 * Can be updated.
 */
class Converter implements Conversions {
 /**
 * Variable accessed by whole class and behave itself a counter of amount
 * left brackets from already read line.
 */
 private static int leftParents = 0;
 /**
 * Variable accessed by whole class and behave itself a counter of amount
 * right brackets from already read line.
 */
 private static int rightParents = 0;

 @Override
 public String convertInfixIntoPostfix(String expression) {
 StringBuilder postfixForm = new StringBuilder();

 String[] separatedExpression = expression.split(" ");
 Stack<String> operationsStack = new Stack<>();

 try {
 if (!checkForExpressionsCorrectness(separatedExpression)) {
 throw new InvalidExpression();
 }

 for (int i = 0; i < separatedExpression.length; i++) {
 String currentStringElem = separatedExpression[i];

 if (i == 0 && !(isOperand(currentStringElem))) {
 throw new InvalidExpression();
 }

 if (isOperand(currentStringElem) && (i % 2 == 0)) {
 currentStringElem = deleteAndCheckForBrackets(currentStringElem, operationsStack);

 if (postfixForm.length() == 0) {
 postfixForm.append(currentStringElem);
 continue;
 }

 postfixForm.append(" ").append(currentStringElem);

 if (leftParents > 0 && rightParents > 0) {
 while (Math.min(leftParents, rightParents) > 0) {
 postfixForm
 .append(" ")
 .append(reversed(operationsStack.uploadExpressionInParentsInString()));
 leftParents--;
 rightParents--;
 }
 }

 continue;
 }


 if (isSign(currentStringElem.charAt(0)) && (i % 2 != 0)) {

 if (operationsStack.depth() == 0) {
 operationsStack.push(currentStringElem);
 continue;
 }

 if (
 Signs.signsComparison(operationsStack.getFirstFromTop().charAt(0), currentStringElem.charAt(0))
 ) {
 postfixForm.append(" ").append(reversed(operationsStack.uploadStackInString()));
 operationsStack.push(currentStringElem);
 } else {
 operationsStack.push(currentStringElem);
 }
 continue;
 }

 throw new InvalidExpression();
 }


 } catch (Exception e) {
 System.out.println(e.getMessage());
 System.exit(0);
 }

 postfixForm.append(" ").append(reversed(operationsStack.uploadStackInString()));

 return postfixForm.toString();
 }

 private boolean isOperand(String elem) {
 if (elem.length() == 1) {
 return Character.isDigit(elem.charAt(0));
 }

 return true;
 }

 private boolean isSign(Character elem) {
 return (Signs.parseSign(elem) != null);
 }

 private String reversed(String string) {
 return new StringBuilder(string).reverse().toString();
 }

 private boolean checkForExpressionsCorrectness(String[] separatedExpression) {
 return separatedExpression.length % 2 != 0 && separatedExpression.length > 2;
 }

 private String deleteAndCheckForBrackets(String string, Stack<String> stack) {
 String correctString = string;

 if (string.charAt(0) == '(' && string.charAt(string.length() - 1) == ')') {
 correctString = string.substring(string.lastIndexOf("(") + 1, string.indexOf(")"));
 } else if (string.charAt(string.length() - 1) == ')') {
 correctString = string.substring(0, string.indexOf(")"));

 for (int i = 0; i < string.length() - string.indexOf(")"); i++) {
 rightParents++;
 stack.push(")");
 }

 } else if (string.charAt(0) == '(') {
 correctString = string.substring(string.lastIndexOf("(") + 1);

 for (int i = 0; i < string.lastIndexOf("(") + 1; i++) {
 leftParents++;
 stack.push("(");
 }
 }

 return correctString;
 }
}

enum Signs {
 PLUS,
 MINUS,
 MUL,
 DIV,
 LEFT_BRACKET,
 RIGHT_BRACKET;
 private static final int ASCII_MUL = 42;
 private static final int ASCII_PLUS = 43;
 private static final int ASCII_MINUS = 45;
 private static final int ASCII_DIV = 47;
 private static final int ASCII_LEFT_BRACKET = 40;
 private static final int ASCII_RIGHT_BRACKET = 41;

 public static Signs parseSign(Character elem) {
 return switch (elem) {
 case (ASCII_MUL) -> Signs.MUL;
 case (ASCII_PLUS) -> Signs.PLUS;
 case (ASCII_MINUS) -> Signs.MINUS;
 case (ASCII_DIV) -> Signs.DIV;
 case (ASCII_LEFT_BRACKET) -> Signs.LEFT_BRACKET;
 case (ASCII_RIGHT_BRACKET) -> Signs.RIGHT_BRACKET;
 default -> null;
 };
 }

 // If elem_1 < elem_2 == 0
 // Else == 1
 public static boolean signsComparison(Character elem1, Character elem2) {
 Signs sign1 = parseSign(elem1);
 Signs sign2 = parseSign(elem2);
 if ((sign1 == PLUS || sign1 == MINUS) && (sign2 == MUL || sign2 == DIV)) {
 return false;
 }
 if ((sign1 == LEFT_BRACKET || sign1 == RIGHT_BRACKET) || (sign2 == LEFT_BRACKET || sign2 == RIGHT_BRACKET)) {
 return false;
 }

 return true;
 }
}

class InvalidExpression extends Exception {
 @Override
 public String getMessage() {
 return "Invalid expression\n";
 }
}