Check if a String is a Palindrome in Java

1. Introduction

In this article, we’re going to see how we can check whether a given String is a palindrome using Java.

A palindrome is a word, phrase, number, or other sequences of characters which reads the same backward as forward, such as “madam” or “racecar”.

2. Solutions

In the following sections, we’ll look at the various ways of checking if a given String is a palindrome or not.

2.1. A Simple Approach

We can simultaneously start iterating the given string forward and backward, one character at a time. If the there is a match the loop continues; otherwise, the loop exits:

public boolean isPalindrome(String text) {
    String clean = text.replaceAll("\\s+", "").toLowerCase();
    int length = clean.length();
    int forward = 0;
    int backward = length - 1;
    while (backward > forward) {
        char forwardChar = clean.charAt(forward++);
        char backwardChar = clean.charAt(backward--);
        if (forwardChar != backwardChar)
            return false;
    }
    return true;
}

2.2. Reversing the String

There are a few different implementations that fit this use case: we can make use of the API methods from StringBuilder and StringBuffer classes when checking for palindromes, or we can reverse the String without these classes.

Let’s take a look at the code implementations without the helper APIs first:

public boolean isPalindromeReverseTheString(String text) {
    StringBuilder reverse = new StringBuilder();
    String clean = text.replaceAll("\\s+", "").toLowerCase();
    char[] plain = clean.toCharArray();
    for (int i = plain.length - 1; i >= 0; i--) {
        reverse.append(plain[i]);
    }
    return (reverse.toString()).equals(clean);
}

In the above snippet, we simply iterate the given String from the last character and append each character to the next character, all the way through to the first character thereby reversing the given String.

Finally, we test for equality between the given String and reversed String.

The same behavior could be achieved using API methods.

Let’s see a quick demonstration:

public boolean isPalindromeUsingStringBuilder(String text) {
    String clean = text.replaceAll("\\s+", "").toLowerCase();
    StringBuilder plain = new StringBuilder(clean);
    StringBuilder reverse = plain.reverse();
    return (reverse.toString()).equals(clean);
}

public boolean isPalindromeUsingStringBuffer(String text) {
    String clean = text.replaceAll("\\s+", "").toLowerCase();
    StringBuffer plain = new StringBuffer(clean);
    StringBuffer reverse = plain.reverse();
    return (reverse.toString()).equals(clean);
}

In the code snippet, we invoke the reverse() method from the StringBuilder and StringBuffer API to reverse the given String and test for equality.

2.3. Using Stream API

We can also use an IntStream to provide a solution:

public boolean isPalindromeUsingIntStream(String text) {
    String temp  = text.replaceAll("\\s+", "").toLowerCase();
    return IntStream.range(0, temp.length() / 2)
      .noneMatch(i -> temp.charAt(i) != temp.charAt(temp.length() - i - 1));
}

In the snippet above, we verify that none of the pairs of characters from each end of the String fulfills the Predicate condition.

2.4. Using Recursion

Recursion is a very popular method to solve these kinds of problems. In the example demonstrated we recursively iterate the given String and test to find out whether it’s a palindrome or not:

public boolean isPalindromeRecursive(String text){
    String clean = text.replaceAll("\\s+", "").toLowerCase();
    return recursivePalindrome(clean,0,clean.length()-1);
}

private boolean recursivePalindrome(String text, int forward, int backward) {
    if (forward == backward) {
        return true;
    }
    if ((text.charAt(forward)) != (text.charAt(backward))) {
        return false;
    }
    if (forward < backward + 1) {
        return recursivePalindrome(text, forward + 1, backward - 1);
    }

    return true;
}

3. Conclusion

In this quick tutorial, we saw how to find out whether a given String is a palindrome or not.

As always, the code examples for this article are available over on GitHub.

Related posts:

Hướng dẫn Java Design Pattern – Memento
Uploading MultipartFile with Spring RestTemplate
Java Program to Implement Stein GCD Algorithm
The Order of Tests in JUnit
Java Program to Construct an Expression Tree for an Postfix Expression
Send an email with an attachment
Java Program to Perform Addition Operation Using Bitwise Operators
JavaScript Methods of RegExp and String
Java CyclicBarrier vs CountDownLatch
Guide to Spring 5 WebFlux
Spring Boot with Multiple SQL Import Files
Comparing Objects in Java
Java Program to do a Depth First Search/Traversal on a graph non-recursively
Stack Memory and Heap Space in Java
JUnit 5 for Kotlin Developers
Using Spring @ResponseStatus to Set HTTP Status Code
Pagination and Sorting using Spring Data JPA
How to Read a Large File Efficiently with Java
Java Program to Implement Branch and Bound Method to Perform a Combinatorial Search
Java Program to Search Number Using Divide and Conquer with the Aid of Fibonacci Numbers
Java Program to Generate Random Partition out of a Given Set of Numbers or Characters
Java Program to Implement Adjacency List
Guide to the Synchronized Keyword in Java
Java Program to Find Location of a Point Placed in Three Dimensions Using K-D Trees
Spring RestTemplate Request/Response Logging
4 tính chất của lập trình hướng đối tượng trong Java
MyBatis with Spring
Java Program to Implement a Binary Search Algorithm for a Specific Search Sequence
Generate a String
The Modulo Operator in Java
Java Stream Filter with Lambda Expression
Java Program to Implement Shunting Yard Algorithm