java 如何判断回文

Java可以通过多种方法判断回文，包括使用字符串反转、双指针技术和递归方法等。 其中，最常见的方法是通过反转字符串并比较原字符串和反转后的字符串是否相同。此外，还可以通过双指针技术，即从字符串的两端向中间移动，逐一比较字符是否相同。以下将详细介绍这些方法，并提供代码示例。

一、字符串反转法

字符串反转法是判断回文最简单的方法之一。其核心思想是通过将字符串反转，然后与原字符串进行比较。如果两者相等，则该字符串是回文。

1.1 实现步骤

获取原字符串。
将字符串反转。
比较原字符串和反转后的字符串是否相等。

1.2 代码示例

public class PalindromeChecker {
    public static boolean isPalindrome(String s) {
        // 去除非字母数字字符并转换为小写
        String cleaned = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
        // 反转字符串
        String reversed = new StringBuilder(cleaned).reverse().toString();
        // 比较原字符串和反转后的字符串
        return cleaned.equals(reversed);
    }
    public static void main(String[] args) {
        String testString = "A man, a plan, a canal, Panama";
        System.out.println(isPalindrome(testString));  // 输出: true
    }
}

在上述代码中，我们首先使用正则表达式去除字符串中的非字母数字字符，并将其转换为小写。然后，我们通过StringBuilder类的reverse()方法将字符串反转，最后比较原字符串和反转后的字符串是否相等。

二、双指针技术

双指针技术是一种高效的判断回文的方法。其核心思想是从字符串的两端同时向中间移动指针，逐一比较字符是否相同。如果所有对应字符都相同，则该字符串是回文。

2.1 实现步骤

初始化两个指针，分别指向字符串的开头和结尾。
比较两个指针所指向的字符是否相同。
如果相同，移动指针；如果不同，返回false。
重复步骤2和3，直到两个指针相遇。

2.2 代码示例

public class PalindromeChecker {
    public static boolean isPalindrome(String s) {
        // 去除非字母数字字符并转换为小写
        String cleaned = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
        int left = 0;
        int right = cleaned.length() - 1;
        while (left < right) {
            if (cleaned.charAt(left) != cleaned.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
    public static void main(String[] args) {
        String testString = "A man, a plan, a canal, Panama";
        System.out.println(isPalindrome(testString));  // 输出: true
    }
}

在上述代码中，我们首先使用正则表达式去除字符串中的非字母数字字符，并将其转换为小写。然后，我们初始化两个指针，分别指向字符串的开头和结尾，逐一比较对应字符是否相同。如果所有字符都相同，则该字符串是回文。

三、递归方法

递归方法是一种使用递归函数判断回文的方法。其核心思想是通过递归调用函数，逐一比较字符串的首尾字符是否相同，然后递归处理剩余的子字符串。

3.1 实现步骤

定义递归函数，接受字符串和两个指针参数。
比较两个指针所指向的字符是否相同。
如果相同，递归调用函数，处理剩余的子字符串；如果不同，返回false。
递归终止条件是两个指针相遇。

3.2 代码示例

public class PalindromeChecker {
    public static boolean isPalindrome(String s) {
        // 去除非字母数字字符并转换为小写
        String cleaned = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
        return isPalindromeRecursive(cleaned, 0, cleaned.length() - 1);
    }
    private static boolean isPalindromeRecursive(String s, int left, int right) {
        if (left >= right) {
            return true;
        }
        if (s.charAt(left) != s.charAt(right)) {
            return false;
        }
        return isPalindromeRecursive(s, left + 1, right - 1);
    }
    public static void main(String[] args) {
        String testString = "A man, a plan, a canal, Panama";
        System.out.println(isPalindrome(testString));  // 输出: true
    }
}

在上述代码中，我们首先使用正则表达式去除字符串中的非字母数字字符，并将其转换为小写。然后，我们定义一个递归函数isPalindromeRecursive，该函数接受字符串和两个指针参数，逐一比较对应字符是否相同。如果所有字符都相同，则该字符串是回文。

四、使用栈数据结构

栈是一种后进先出的数据结构，可以用来判断回文。其核心思想是将字符串的一半入栈，然后逐一比较栈顶元素和字符串的另一半字符是否相同。

4.1 实现步骤

将字符串的一半入栈。
从字符串的中间开始，逐一比较栈顶元素和字符串的另一半字符是否相同。
如果所有字符都相同，则该字符串是回文。

4.2 代码示例

import java.util.Stack;
public class PalindromeChecker {
    public static boolean isPalindrome(String s) {
        // 去除非字母数字字符并转换为小写
        String cleaned = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
        Stack<Character> stack = new Stack<>();
        int len = cleaned.length();
        for (int i = 0; i < len / 2; i++) {
            stack.push(cleaned.charAt(i));
        }
        for (int i = (len + 1) / 2; i < len; i++) {
            if (stack.isEmpty() || stack.pop() != cleaned.charAt(i)) {
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) {
        String testString = "A man, a plan, a canal, Panama";
        System.out.println(isPalindrome(testString));  // 输出: true
    }
}

在上述代码中，我们首先使用正则表达式去除字符串中的非字母数字字符，并将其转换为小写。然后，我们将字符串的一半字符入栈，并从字符串的中间开始，逐一比较栈顶元素和字符串的另一半字符是否相同。如果所有字符都相同，则该字符串是回文。

五、使用队列数据结构

队列是一种先进先出的数据结构，也可以用来判断回文。其核心思想是将字符串的一半入队，然后逐一比较队头元素和字符串的另一半字符是否相同。

5.1 实现步骤

将字符串的一半入队。
从字符串的中间开始，逐一比较队头元素和字符串的另一半字符是否相同。
如果所有字符都相同，则该字符串是回文。

5.2 代码示例

import java.util.LinkedList;
import java.util.Queue;
public class PalindromeChecker {
    public static boolean isPalindrome(String s) {
        // 去除非字母数字字符并转换为小写
        String cleaned = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
        Queue<Character> queue = new LinkedList<>();
        int len = cleaned.length();
        for (int i = 0; i < len / 2; i++) {
            queue.offer(cleaned.charAt(i));
        }
        for (int i = (len + 1) / 2; i < len; i++) {
            if (queue.isEmpty() || queue.poll() != cleaned.charAt(i)) {
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) {
        String testString = "A man, a plan, a canal, Panama";
        System.out.println(isPalindrome(testString));  // 输出: true
    }
}

在上述代码中，我们首先使用正则表达式去除字符串中的非字母数字字符，并将其转换为小写。然后，我们将字符串的一半字符入队，并从字符串的中间开始，逐一比较队头元素和字符串的另一半字符是否相同。如果所有字符都相同，则该字符串是回文。

六、结论

通过上述几种方法，我们可以高效地判断一个字符串是否为回文。每种方法都有其优点和适用场景：

字符串反转法：实现简单，适用于一般场景，但空间复杂度较高。
双指针技术：效率高，适用于大多数场景，是常用的方法。
递归方法：代码简洁，但可能导致栈溢出，适用于小规模字符串。
栈数据结构：适用于需要保留字符顺序的场景，但空间复杂度较高。
队列数据结构：适用于需要保留字符顺序的场景，但空间复杂度较高。

根据具体需求和场景，选择合适的方法可以更高效地解决问题。无论是字符串反转、双指针、递归、栈还是队列，每种方法都有其独特的优势和适用场景。希望本文对你在实际开发中判断回文字符串有所帮助。