在 Java 中检查回文

JavaJavaBeginner
立即练习

💡 本教程由 AI 辅助翻译自英文原版。如需查看原文,您可以 切换至英文原版

介绍

在本实验中,我们将学习如何在 Java 中检查一个字符串是否是回文。回文是指正读和反读都相同的字符串。


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("`Java`")) -.-> java/BasicSyntaxGroup(["`Basic Syntax`"]) java(("`Java`")) -.-> java/StringManipulationGroup(["`String Manipulation`"]) java(("`Java`")) -.-> java/DataStructuresGroup(["`Data Structures`"]) java(("`Java`")) -.-> java/ProgrammingTechniquesGroup(["`Programming Techniques`"]) java(("`Java`")) -.-> java/FileandIOManagementGroup(["`File and I/O Management`"]) java(("`Java`")) -.-> java/SystemandDataProcessingGroup(["`System and Data Processing`"]) java/BasicSyntaxGroup -.-> java/booleans("`Booleans`") java/BasicSyntaxGroup -.-> java/for_loop("`For Loop`") java/BasicSyntaxGroup -.-> java/while_loop("`While Loop`") java/StringManipulationGroup -.-> java/strings("`Strings`") java/DataStructuresGroup -.-> java/arrays_methods("`Arrays Methods`") java/ProgrammingTechniquesGroup -.-> java/recursion("`Recursion`") java/FileandIOManagementGroup -.-> java/stream("`Stream`") java/SystemandDataProcessingGroup -.-> java/string_methods("`String Methods`") subgraph Lab Skills java/booleans -.-> lab-117978{{"`在 Java 中检查回文`"}} java/for_loop -.-> lab-117978{{"`在 Java 中检查回文`"}} java/while_loop -.-> lab-117978{{"`在 Java 中检查回文`"}} java/strings -.-> lab-117978{{"`在 Java 中检查回文`"}} java/arrays_methods -.-> lab-117978{{"`在 Java 中检查回文`"}} java/recursion -.-> lab-117978{{"`在 Java 中检查回文`"}} java/stream -.-> lab-117978{{"`在 Java 中检查回文`"}} java/string_methods -.-> lab-117978{{"`在 Java 中检查回文`"}} end

使用双指针检查回文

我们将实现的第一个方法是双指针法。我们将创建一个名为 isPalindrome 的方法,该方法接收一个字符串作为输入,并返回一个布尔值,指示该字符串是否是回文。

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        int start = 0;
        int end = str.length() - 1;

        while (start < end) {
            char startChar = Character.toLowerCase(str.charAt(start));
            char endChar = Character.toLowerCase(str.charAt(end));

            if (startChar != endChar) {
                return false;
            }

            start++;
            end--;
        }

        return true;
    }
}

isPalindrome 方法使用了两个指针 startend,它们分别从字符串的开头和末尾开始。循环会一直运行,直到两个指针在中间相遇。

在每次迭代中,我们比较 startend 指针处的字符。如果它们不相等,我们返回 false。如果相等,我们更新指针以检查字符串中的下一组字符。

为了测试我们的方法,我们可以添加一个 main 方法,并使用不同的输入字符串调用 isPalindrome 方法。

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementation of isPalindrome method
    }

    public static void main(String[] args) {
        System.out.println("Is 'racecar' a palindrome? " + isPalindrome("racecar"));
        System.out.println("Is 'hello' a palindrome? " + isPalindrome("hello"));
    }
}

使用递归检查回文

接下来我们将实现的方法是递归法。我们将创建一个名为 isPalindromeRecursive 的新方法,该方法接收字符串、起始索引和结束索引作为输入。

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        String lowercaseStr = str.toLowerCase();
        return isPalindromeRecursive(lowercaseStr, 0, lowercaseStr.length() - 1);
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        if(start >= end) {
            return true;
        }

        char startChar = Character.toLowerCase(str.charAt(start));
        char endChar = Character.toLowerCase(str.charAt(end));

        if(startChar != endChar) {
            return false;
        }

        return isPalindromeRecursive(str, start + 1, end - 1);
    }

    public static void main(String[] args) {
        // Tests for isPalindrome and isPalindromeRecursive methods
    }
}

isPalindromeRecursive 方法使用递归来检查字符串是否是回文。我们有两个基本情况:

  1. 如果 start 索引大于或等于 end 索引,这意味着我们已经检查了字符串中的所有字符并且它们匹配,因此我们返回 true
  2. 如果 startend 索引处的字符不相等,我们返回 false

如果以上两种情况都不满足,我们使用更新后的索引再次调用 isPalindromeRecursive 方法。

现在,我们可以在 main 方法中调用递归方法来测试它。

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementation of isPalindrome method
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implementation of isPalindromeRecursive method
    }

    public static void main(String[] args) {
        System.out.println("Is 'racecar' a palindrome? " + isPalindromeRecursive("racecar", 0, 6));
        System.out.println("Is 'hello' a palindrome? " + isPalindromeRecursive("hello", 0, 4));
    }
}

使用字符串反转检查回文

我们将实现的最后一个方法是字符串反转法。我们将创建一个名为 isPalindromeReverse 的新方法,该方法接收一个字符串作为输入。

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementation of isPalindrome method
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implementation of isPalindromeRecursive method
    }

    public static boolean isPalindromeReverse(String str) {
        String reversed = "";

        for (int i = str.length() - 1; i >= 0; i--) {
            reversed += str.charAt(i);
        }

        return str.equalsIgnoreCase(reversed);
    }

    public static void main(String[] args) {
        // Tests for isPalindrome and isPalindromeRecursive methods
        System.out.println("Is 'racecar' a palindrome? " + isPalindromeReverse("racecar"));
        System.out.println("Is 'hello' a palindrome? " + isPalindromeReverse("hello"));
    }
}

isPalindromeReverse 方法创建了一个名为 reversed 的新字符串,并通过从输入字符串的末尾到开头进行迭代来填充它。如果两个字符串在忽略大小写的情况下相等,则返回 true

我们可以在 main 方法中添加对 isPalindromeReverse 的调用来测试该方法。

使用 Java Streams 检查回文

最后,我们将使用 Java Streams API 来检查回文。我们将创建一个名为 isPalindromeStream 的新方法,该方法接收一个字符串作为输入。

import java.util.stream.IntStream;

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implementation of isPalindrome method
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implementation of isPalindromeRecursive method
    }

    public static boolean isPalindromeReverse(String str) {
        // Implementation of isPalindromeReverse method
    }

    public static boolean isPalindromeStream(String str) {
        String lowercaseStr = str.toLowerCase();

        return IntStream.range(0, lowercaseStr.length() / 2)
                .noneMatch(i -> lowercaseStr.charAt(i) != lowercaseStr.charAt(lowercaseStr.length() - i - 1));
    }

    public static void main(String[] args) {
        // Tests for isPalindrome and isPalindromeRecursive methods
        System.out.println("Is 'racecar' a palindrome? " + isPalindromeStream("racecar"));
        System.out.println("Is 'hello' a palindrome? " + isPalindromeStream("hello"));
    }
}

isPalindromeStream 方法使用 IntStream 类生成一系列索引,我们可以使用这些索引来比较字符串中的字符。

我们使用 noneMatch 方法,如果没有任何字符违反 ithn-i-1th 字符相等的条件(其中 n 是字符串的长度,i 是索引),则返回 true

我们可以在 main 方法中添加对 isPalindromeStream 的调用来测试该方法。

总结

在本实验中,我们学习了如何在 Java 中检查给定字符串是否是回文。我们实现了四种不同的方法来完成此任务:

  1. 双指针法
  2. 递归法
  3. 字符串反转法
  4. Java Streams 法

现在你已经理解了这些方法,可以使用它们来解决更复杂的问题!

您可能感兴趣的其他 Java 教程