Palindrome program in Java

Welcome to our step-by-step tutorial on how to build a palindrome checker using Java.

Are you ready to dive into the world of programming and learn how to create a powerful tool to detect palindromes? Look no further—we have you covered!

This tutorial will walk you through building a palindrome checker from scratch using Java. Whether you are a beginner or an experienced programmer, our detailed instructions and explanations will ensure you understand every step of the process.

A palindrome is a word, phrase, or sequence of characters that reads the same backward as forwards.

By creating a palindrome checker, you will be able to input any text and determine whether it is a palindrome or not. This can be a useful tool for language processing, game development, or simply for fun! So, grab your coding tools and get ready to unleash your programming skills.

Let’s get started on building your very own palindrome checker using Java!

What is a palindrome program?

A palindrome program checks if a string is a palindrome, which means we can read it the same backward as forward.

First, let’s write the algorithm of the program.

Give a string as input.
Initialize two index variables so one can move backward and the other forward.
Calculate if the letters in the indexes’ position are the same.
If yes, increase one index, decrease the other, and repeat step 3.
If the letters differ, we can conclude that the string is not a palindrome.

First, we will write a method that checks if the string is a palindrome. This method will take the string as input.

static void checkString(String str)

The string input should be edited to remove white spaces, and all the letters should be lowercase so we can compare them.

str = s1.toLowerCase(); 
str = str.replaceAll("\\s+","");

The two counters will be i and j, holding the index of each letter we will compare.

int i = 0; 
int j = str.length() - 1;

The palindrome has the same letters for i and j positions, so we will check if this expression is true:

str.charAt(i) != str.charAt(j)

The i variable will move forward, and the j variable will move backward. This will continue until I reach j.

So, in a while loop, we will increase i and decrease j:

i++; 
j--;

The final version of the Palindrome program in Java looks like this:

public class Palindrome_Demo {
 static void checkString(String s1)
 {
  String str;
  str = s1.toLowerCase();
  str = str.replaceAll("\\s+","");

  int i = 0;
  int j = str.length() - 1;
  boolean result=true;

  while (i < j) {
   if (str.charAt(i) != str.charAt(j))
    result=false;
   i++;
   j--;
  }
  if (result)
   System.out.print(s1+" is Palindrome");
  else
   System.out.print(s1+" is Not Palindrome");
  }
  public static void main(String[] args)
  {
   String s = "My gym";
   checkString(s);
  }
}

In the Console, the result is:

My gym is Palindrome

Think about A Recursive Version

The palindrome checker also has a recursive version. This is a typical case where the solution can be seen as a recursion: the way we check the whole string, we can check its substring.

Let’s write the algorithm of the recursive method.

Give a string as input.
If the length is 0 or 1, the string is a palindrome.
Check if the string’s first and last characters are identical.
If they are the same, do the same thing for a substring, with the first and last character removed.
Repeat step 3 until the string has the length 0 or 1 or the condition fails.
If the letters differ, we can conclude that the string is not a palindrome.

Palindrome PROGRAM, recursive, IN JAVA

Now, let’s implement the recursive method isPalindrome ( ), which will take a string as input and return a boolean value as a result.

First, the string is checked to see if it has a length of zero or one.

s.length() == 0 || s.length() == 1

The condition to continue the same check to the substring is:

if(s.charAt(0) == s.charAt(s.length()-1))

This means we will continue to apply the same check only if the first and the last character of the string are the same. If so, let’s call the same method isPalindrstring’s ome ( ), bith the new string as input: the string minus the first and last char, so let’s call it:

isPalindrome(s.substring(1, s.length()-1))

The recursion stops if the substring has a length of zero or one.

Note that in the main method, we will edit the string, remove the white spaces, and set all the letters in lowercase.

The full program of palindrome in Java, the recursive version is:

public class Palindrome_Rec_Version {
 public static boolean isPalindrome(String s){   
  if(s.length() == 0 || s.length() == 1)
   return true; 
  if(s.charAt(0) == s.charAt(s.length()-1))
   return isPalindrome(s.substring(1, s.length()-1));
  return false;
}

 public static void main(String[]args) {
  String str="no melon no lemon";
  str=str.toLowerCase();
  str=str.replaceAll("\\s+","");
  if(isPalindrome(str))
   System.out.println(str + " is a palindrome");
  else
   System.out.println(str + " is not a palindrome");
 }
}

In Console:

nomelonnolemon is a palindrome

Hoping this was helpful. Keep coding…

>> For more Java Applications Tutorials, visit Code in Java

How to Build a Palindrome Checker Using Java: A Step-by-Step Tutorial

What is a palindrome program?