Parse And Calc

private static double calc(String formula) {
    if (formula.matches("(\\(*-?\\d+(\\.\\d+)?\\)*)|((\\(*-?\\d+(\\.\\d+)?\\)*([+\\-*x×⋅/÷%^]))+\\(*-?\\d+(\\.\\d+)?\\)*)")) {
        if (!formula.contains("(") && !formula.contains(")")) {
            if (formula.matches("-?\\d+(\\.\\d+)?")) {
                return Double.parseDouble(formula);
            }
            formula = formula.replaceAll("[x×⋅]", "*").replace("÷", "/");
            ArrayList<String> numbers = new ArrayList<>();
            ArrayList<String> operators = new ArrayList<>();
            Matcher matcher = Pattern.compile("-?\\d+(\\.\\d+)?").matcher(formula);
            int start = 0;
            while (matcher.find(start)) {
                start = matcher.end();
                if (matcher.pattern().toString().equals("-?\\d+(\\.\\d+)?")) {
                    numbers.add(matcher.group());
                    matcher = Pattern.compile("[+\\-*x×⋅/÷%^]").matcher(formula);
                } else if (matcher.pattern().toString().equals("[+\\-*x×⋅/÷%^]")) {
                    operators.add(matcher.group());
                    matcher = Pattern.compile("-?\\d+(\\.\\d+)?").matcher(formula);
                }
            }
            if (operators.size() == numbers.size() - 1) {
                Iterator<String> iterator1 = numbers.iterator();
                Iterator<String> iterator2 = operators.iterator();
                ArrayList<String> elements = new ArrayList<>();
                while (iterator1.hasNext()) {
                    elements.add(iterator1.next());
                    if (iterator2.hasNext()) {
                        elements.add(iterator2.next());
                    }
                }
                try {
                    while (elements.contains("^")) {
                        for (int i = 0; i < elements.size(); i++) {
                            if (elements.get(i).equals("^")) {
                                elements.set(i, Double.toString(Math.pow(Double.parseDouble(elements.get(i - 1)), Double.parseDouble(elements.get(i + 1)))));
                                elements.remove(i + 1);
                                elements.remove(i - 1);
                            }
                        }
                    }
                    while (elements.contains("*") || elements.contains("/") || elements.contains("%")) {
                        for (int i = 0; i < elements.size(); i++) {
                            if (elements.get(i).equals("*")) {
                                elements.set(i, Double.toString(Double.parseDouble(elements.get(i - 1)) * Double.parseDouble(elements.get(i + 1))));
                                elements.remove(i + 1);
                                elements.remove(i - 1);
                            } else if (elements.get(i).equals("/")) {
                                elements.set(i, Double.toString(Double.parseDouble(elements.get(i - 1)) / Double.parseDouble(elements.get(i + 1))));
                                elements.remove(i + 1);
                                elements.remove(i - 1);
                            } else if (elements.get(i).equals("%")) {
                                elements.set(i, Double.toString(Double.parseDouble(elements.get(i - 1)) % Double.parseDouble(elements.get(i + 1))));
                                elements.remove(i + 1);
                                elements.remove(i - 1);
                            }
                        }
                    }
                    while (elements.contains("+") || elements.contains("-")) {
                        for (int i = 0; i < elements.size(); i++) {
                            if (elements.get(i).equals("+")) {
                                elements.set(i, Double.toString(Double.parseDouble(elements.get(i - 1)) + Double.parseDouble(elements.get(i + 1))));
                                elements.remove(i + 1);
                                elements.remove(i - 1);
                            } else if (elements.get(i).equals("-")) {
                                elements.set(i, Double.toString(Double.parseDouble(elements.get(i - 1)) - Double.parseDouble(elements.get(i + 1))));
                                elements.remove(i + 1);
                                elements.remove(i - 1);
                            }
                        }
                    }
                    if (elements.size() == 1) {
                        return Double.parseDouble(elements.get(0));
                    }
                } catch (NumberFormatException ignored) {}
            }
        } else {
            while (formula.contains("(") || formula.contains(")")) {
                ArrayList<Integer> openingBrackets = new ArrayList<>();
                ArrayList<Integer> closeBrackets = new ArrayList<>();
                int firstOpeningBracket = -1;
                while ((firstOpeningBracket = formula.indexOf("(", firstOpeningBracket + 1)) != -1) {
                    openingBrackets.add(firstOpeningBracket);
                }
                int firstCloseBracket = -1;
                while ((firstCloseBracket = formula.indexOf(")", firstCloseBracket + 1)) != -1) {
                    closeBrackets.add(firstCloseBracket);
                }
                if (openingBrackets.size() == closeBrackets.size()) {
                    int insideCloseBracket = Collections.min(closeBrackets);
                    int insideOpeningBracket = Collections.max(openingBrackets, (i1, i2) -> {
                        if (i1 > insideCloseBracket && i2 < insideCloseBracket) {
                            return i2 - i1;
                        } else {
                            return i1 - i2;
                        }
                    });
                    ArrayList<Character> chars = new ArrayList<>();
                    formula.chars().mapToObj((i) -> (char) i).forEach(chars::add);
                    chars.subList(insideOpeningBracket, insideCloseBracket + 1).clear();
                    ArrayList<Character> answerChars = new ArrayList<>();
                    Double.toString(calc(formula.substring(insideOpeningBracket + 1, insideCloseBracket))).chars().mapToObj((i) -> (char) i).forEach(answerChars::add);
                    Collections.reverse(answerChars);
                    answerChars.forEach((character) -> chars.add(insideOpeningBracket, character));
                    StringBuilder sb = new StringBuilder();
                    chars.forEach(sb::append);
                    formula = sb.toString();
                } else {
                    return 0;
                }
            }
            return calc(formula);
        }
    }
    return 0;
}