Infix to Prefix Conversion in Java

import java.util.Stack;

public class InfixToPrefix {

    private static boolean isOperand(char ch) {
        return Character.isLetterOrDigit(ch);
    }

    private static boolean isOperator(char ch) {
        return ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '^';
    }

    private static int precedence(char op) {
        switch (op) {
            case '^': return 3;
            case '*':
            case '/': return 2;
            case '+':
            case '-': return 1;
            default:  return -1;
        }
    }

    // ^ is right-associative, others are left-associative
    private static boolean isRightAssociative(char op) {
        return op == '^';
    }

    private static String reverseAndSwapParentheses(String s) {
        StringBuilder sb = new StringBuilder();

        for (int i = s.length() - 1; i >= 0; i--) {
            char ch = s.charAt(i);
            if (ch == '(') sb.append(')');
            else if (ch == ')') sb.append('(');
            else sb.append(ch);
        }
        return sb.toString();
    }

    // Standard infix-to-postfix conversion, used internally after reverse+swap
    private static String toPostfix(String infix) {
        Stack ops = new Stack<>();
        StringBuilder postfix = new StringBuilder();

        for (int i = 0; i < infix.length(); i++) {
            char ch = infix.charAt(i);

            if (ch == ' ') continue; // ignore spaces

            if (isOperand(ch)) {
                postfix.append(ch);
            } else if (ch == '(') {
                ops.push(ch);
            } else if (ch == ')') {
                while (!ops.isEmpty() && ops.peek() != '(') {
                    postfix.append(ops.pop());
                }
                if (!ops.isEmpty() && ops.peek() == '(') ops.pop();
                else throw new IllegalArgumentException("Mismatched parentheses");
            } else if (isOperator(ch)) {
                while (!ops.isEmpty() && isOperator(ops.peek())) {
                    char top = ops.peek();

                    // Pop if top has higher precedence
                    // Or same precedence and current operator is left-associative
                    if (precedence(top) > precedence(ch) ||
                        (precedence(top) == precedence(ch) && !isRightAssociative(ch))) {
                        postfix.append(ops.pop());
                    } else {
                        break;
                    }
                }
                ops.push(ch);
            } else {
                throw new IllegalArgumentException("Invalid character: " + ch);
            }
        }

        while (!ops.isEmpty()) {
            if (ops.peek() == '(') throw new IllegalArgumentException("Mismatched parentheses");
            postfix.append(ops.pop());
        }

        return postfix.toString();
    }

    public static String infixToPrefix(String infix) {
        String reversed = reverseAndSwapParentheses(infix);
        String postfix = toPostfix(reversed);
        return new StringBuilder(postfix).reverse().toString();
    }

    public static void main(String[] args) {
        String infix = "(A-B/C)*(A/K-L)";
        String prefix = infixToPrefix(infix);

        System.out.println("Infix  : " + infix);
        System.out.println("Prefix : " + prefix);
    }
}