Считаем математическое выражение.

    public double expression(String str) {
        //str содержит математическое выражение без пробелов
        if (check_brackets(str)) {
            System.out.println ("Скобки успешно совпадают!");
            return calculate(getTokens(f(str)));
        } else {
            System.out.println ("Соответствие скобок не выполнено или содержит неправильные скобки!");
        }
        return Double.NaN;
    }

    /**
     *
     * @param str
     * Входящая полная тестовая строка арифметического выражения
     * @return возвращает логическое значение, если совпадение успешно, возвращает true, иначе false
     */
    public boolean check_brackets(String str) {
        Stack<Character> s = new Stack<Character>();
        /**********************************/
        char[] ch = new char[128];
        ch['1'] = '1';
        ch['2'] = '2';
        ch['3'] = '3';
        ch['4'] = '4';
        ch['5'] = '5';
        ch['6'] = '6';
        ch['7'] = '7';
        ch['8'] = '8';
        ch['9'] = '9';
        ch['0'] = '0';
        ch['('] = '(';
        ch[')'] = ')';
        ch['['] = '[';
        ch[']'] = ']';
        ch['{'] = '{';
        ch['}'] = '}';
        ch['.'] = '.';
        ch['+'] = '+';
        ch['-'] = '-';
        ch['*'] = '*';
        ch['/'] = '/';
        /**********************************/
        for (int i = 0; i < str.length(); i++) {
            char t = str.charAt(i);
            if (t > 128 || ch[t] != t) {
                return false;
            }
            if (t == '(' || t == '[' || t == '{') {
                s.push(t);
            } else if (t == ')' || t == ']' || t == '}') {
                char temp = '\u0000';
                if (s.size() > 0)
                    temp = s.pop();
                else
                    return false;
                if (!((temp == '(' && t == ')') || (temp == '[' && t == ']') || (temp == '{' && t == '}'))) {
                    return false;
                }
            } else {

            }
        }
        if (s.size() != 0)
            return false;
        return true;
        /**********************************/
    }

    /**
     *
     * @param str
     * Входящая полная тестовая строка арифметического выражения
     * @return Полная строка теста арифметического выражения, состоящая из каждого элемента массива
     */
    public Object[] f(String str) {
        Stack<Object> s = new Stack<Object>();
        int left = 0, right = 0, tag = ((str.charAt(0) >= '0' && str.charAt(0) <= '9')
                || (str.charAt(0) == '.') ? 0 : 1);
        for (int i = 0; i < str.length(); i++) {
            char t = str.charAt(i);
            if ((t >= '0' && t <= '9') || (t == '.')) {
                right++;
                tag = 0;
            } else {
                if (left != right) {
                    s.push(new Double(str.substring(left, right)));
                    left = right;
                }
                right++;
                s.push(str.substring(left, right));
                left = right;
                tag = 1;
            }
            if (right == str.length()) {
                if (left != right) {
                    if (tag == 1)
                        s.push(str.substring(left, right));
                    else
                        s.push(new Double(str.substring(left, right)));
                    left = right;
                }
            }
        }
        System.out.println(Arrays.toString(s.toArray()));
        return s.toArray();
    }

    /**
     * Получить суффиксное выражение
     *
     * @param f
     * Полная тестовая строка арифметического выражения, состоящая из каждого элемента массива
     * @return массив выражений суффиксов
     */
    public Object[] getTokens(Object[] f) {
        Stack<Object> s = new Stack<Object>();
        Stack<Object> n = new Stack<Object>();
        for (int i = 0; i < f.length; i++) {
            if (f[i].equals("(") || f[i].equals("[") || f[i].equals("{")) {
                s.push("(");
            } else if (f[i].equals("*")) {
                while ("/".equals((s.size() > 0) ? s.lastElement() : "")) {
                    n.push(s.pop());
                }
                s.push("*");
            } else if (f[i].equals("/")) {
                while ("*".equals((s.size() > 0) ? s.lastElement() : "")) {
                    n.push(s.pop());
                }
                s.push("/");
            } else if (f[i].equals("+")) {
                while (("*".equals((s.size() > 0) ? s.lastElement() : ""))
                        || ("/").equals((s.size() > 0) ? s.lastElement() : "")
                        || ("-").equals((s.size() > 0) ? s.lastElement() : "")) {
                    n.push(s.pop());
                }
                s.push("+");
            } else if (f[i].equals("-")) {
                while (("*".equals((s.size() > 0) ? s.lastElement() : ""))
                        || ("/").equals((s.size() > 0) ? s.lastElement() : "")
                        || ("+").equals((s.size() > 0) ? s.lastElement() : "")) {
                    n.push(s.pop());
                }
                s.push("-");
            } else if (f[i].equals(")") || f[i].equals("]") || f[i].equals("}")) {
                while (!"(".equals((s.size() > 0) ? s.lastElement() : "")) {
                    n.push(s.pop());
                }
                s.pop();
            } else {
                n.push(f[i]);
            }
        }
        while (s.size() > 0)
            n.push(s.pop());
        return n.toArray();
    }

    /**
     * Расчет
     *
     * @param f
     * @return
     */
    public double calculate(Object[] f) {
        Stack<Object> s = new Stack<Object>();
        for (int i = 0; i < f.length; i++) {
            if (f[i] instanceof Double) {
                s.push(f[i]);
            } else if ("+".equals(f[i])) {
                double left = (double) s.pop();
                double right = (double) s.pop();
                s.push(add(right, left));
            } else if ("-".equals(f[i])) {
                double left = (double) s.pop();
                double right = (double) s.pop();
                s.push(sub(right, left));
            } else if ("*".equals(f[i])) {
                double left = (double) s.pop();
                double right = (double) s.pop();
                s.push(mul(right, left));
            } else if ("/".equals(f[i])) {
                double left = (double) s.pop();
                double right = (double) s.pop();
                s.push(div(right, left));
            } else {

            }
        }
        return (double) s.pop();
    }

    public double add(double a, double b) {
        return a + b;
    }

    public double sub(double a, double b) {
        return a - b;
    }

    public double mul(double a, double b) {
        return a * b;
    }

    public double div(double a, double b) {
        return a / b;
    }