Удаление дублирующихся символов.Вывод сообщения об ошибке

import java.math.BigDecimal;
import java.util.*;
import java.io.*;
public class Calc {
    /**
     * @param args
     */
    public static  Map<String, Integer> MAIN_MATH_OPERATIONS;
     static {
         MAIN_MATH_OPERATIONS = new HashMap<String, Integer>();
         MAIN_MATH_OPERATIONS.put("*", 1);
         MAIN_MATH_OPERATIONS.put("/", 1);
         MAIN_MATH_OPERATIONS.put("+", 2);
         MAIN_MATH_OPERATIONS.put("-", 2);
         }
     public static String sortingStation(String expression, Map<String, Integer> operations, String leftBracket, String rightBracket) 
     {
         if (expression == null || expression.length() == 0)
             throw new IllegalStateException("Введите выражение");
             if (operations == null || operations.isEmpty())
             throw new IllegalStateException("Операторы отсутствуют!");
             List<String> out = new ArrayList<String>();
             Stack<String> stack = new Stack<String>();
             expression = expression.replace("=", "");
             expression = expression.replace(" ", "");
             Set<String> operationSymbols = new HashSet<String>(operations.keySet());
             operationSymbols.add(leftBracket);
             operationSymbols.add(rightBracket);
             int index = 0;
            boolean findNext = true;
            while (findNext) {
            int nextOperationIndex = expression.length();
            String nextOperation = "";
            for (String operation : operationSymbols) {
            int i = expression.indexOf(operation, index);
            if (i >= 0 && i < nextOperationIndex) {
            nextOperation = operation;
            nextOperationIndex = i;
            }
            
            }
             if (nextOperationIndex == expression.length()) {
                 findNext = false;
                 } else {
                     if (index != nextOperationIndex) {
                         out.add(expression.substring(index, nextOperationIndex));
                         }
                     if (nextOperation.equals(leftBracket)) {
                         stack.push(nextOperation);
                         }
                 else if (nextOperation.equals(rightBracket)) {
                         while (!stack.peek().equals(leftBracket)) {
                         out.add(stack.pop());
                         if (stack.empty()) {
                            throw new IllegalArgumentException("Некорректное количество скобок");
                         }
                         }
                         stack.pop();
                         }
                     else {
                         while (!stack.empty() && !stack.peek().equals(leftBracket) &&
                         (operations.get(nextOperation) >= operations.get(stack.peek()))) {
                         out.add(stack.pop());
                         }
                         stack.push(nextOperation);
                         }
                         index = nextOperationIndex + nextOperation.length();
                         }
                         }
             if (index != expression.length()) {
                 out.add(expression.substring(index));
                 }
             while (!stack.empty()) {
                 out.add(stack.pop());
                 }
                 StringBuffer result = new StringBuffer();
                 if (!out.isEmpty())
                 result.append(out.remove(0));
                 while (!out.isEmpty())
                 result.append(" ").append(out.remove(0));
                  
                 return result.toString(); 
     }
     
     public static String sortingStation(String expression, Map<String, Integer> operations) {
         return sortingStation(expression, operations, "(", ")");
         }
     
     public static BigDecimal calculateExpression(String expression) {
         String rpn = sortingStation(expression, MAIN_MATH_OPERATIONS);
         StringTokenizer tokenizer = new StringTokenizer(rpn, " ");
         Stack<BigDecimal> stack = new Stack<BigDecimal>();
         while (tokenizer.hasMoreTokens()) {
         String token = tokenizer.nextToken();
         if (!MAIN_MATH_OPERATIONS.keySet().contains(token)) {
         stack.push(new BigDecimal(token));
         } else {
         BigDecimal operand2 = stack.pop();
         BigDecimal operand1 = stack.empty() ? BigDecimal.ZERO : stack.pop();
         if (token.equals("*")) {
         stack.push(operand1.multiply(operand2));
         } else if (token.equals("/")) {
         stack.push(operand1.divide(operand2));
         } else if (token.equals("+")) {
         stack.push(operand1.add(operand2));
         } else if (token.equals("-")) {
         stack.push(operand1.subtract(operand2));
         
         }
         }
         }
         if (stack.size() != 1)
         throw new IllegalArgumentException("Некорректно введено выражение.");
         return stack.pop();
         }
     
    public static void main(String[] args) throws IOException 
    { String key;
    do
    {
        BufferedReader bReader = new
    BufferedReader (new InputStreamReader(System.in)); 
    System.out.println("\n" +
            "Выберите действие\n" +
            "1 - Вычислить произвольное выражение\n" +
            "2 - Выйти");
    key=bReader.readLine();
    if (key.equals("1"))
        
    {System.out.println("Введите выражение для вычисления.");
    //String expression = " 3 + 4 * 2 / (1 - 5) + 2";
    String expression;
    expression = bReader.readLine();
    System.out.println("Исходное выражение: " + expression);
    String rpn = sortingStation(expression, MAIN_MATH_OPERATIONS);
    System.out.println("Обратная польская нотация: " + rpn);
    System.out.println("\tРезультат " + calculateExpression(expression));
    }
    else if (key.equals("2")) 
    {System.exit(0);}
    else {
        System.out.println("Неправильно выбраный пункт!!!");
    }
    }while(!key.equals("1,2"));
    }
    }