Comprobar si String es Palindrome en Java

1. Use punteros para verificar si una cadena es un palíndromo en Java
2. Invierta la cadena para verificar si una cadena es un palíndromo en Java
3. Use recursividad para verificar si una cadena es un palíndromo en Java
4. Conclusión

Si los caracteres de una cadena de derecha a izquierda son los mismos que los caracteres de la cadena de izquierda a derecha, lo llamamos palíndromo. Cadenas como ababa, radar y ppqpp son algunos ejemplos.

Aquí, el primer carácter es el mismo que el último carácter; el segundo carácter es el mismo que el penúltimo carácter, etc. En este artículo, veremos varios programas de Java para verificar si una cadena es un palíndromo o no.

Use punteros para verificar si una cadena es un palíndromo en Java

Una idea muy simple para verificar si una cadena es un palíndromo o no es usar dos punteros; uno apunta al comienzo de la cadena y el otro apunta al final de la cadena. Considere el siguiente código.

public class PalProgram {
  static boolean PalFunc(String s)

  {
    // Pointer i pointing to the start and j pointing to the end
    int i = 0, j = s.length() - 1;

    while (i < j) {
      // Check if there is any mis-matching pair
      if (s.charAt(i) != s.charAt(j))
        return false;

      // Update the pointers
      i++;
      j--;
    }

    // If no mismatch occurs
    return true;
  }

  public static void main(String[] args) {
    String s = "ava";
    s = s.toLowerCase();
    if (PalFunc(s))
      System.out.print("Yes, it is a palindrome.");

    else
      System.out.print("No, it is not a palindrome.");
  }
}

Producción :

Yes, it is a palindrome.

Aquí, dentro de la función PalFunc, el primer puntero i apuntará al principio de la cadena, y el segundo puntero j apuntará al final de la cadena, lo que tenemos que comprobar si es un palíndromo o no.

Luego, ejecutaremos un bucle hasta i<j. En cada paso, comprobamos si los caracteres señalados por estos dos punteros, i y j, coinciden o no.

Además, simultáneamente incrementamos i y decrementamos j en uno. Si los caracteres no coinciden en ningún paso, devolvemos false notificando al usuario que la cadena no es un palíndromo.

Estamos usando la función toLowerCase() en nuestro ejemplo. El compilador de Java compara dos caracteres en función de sus valores ASCII.

Significa que A == a evaluará false. En este caso, la cadena abA no se considerará un palíndromo en Java, que no es el escenario real.

Es por eso que primero debemos convertir la cadena a mayúsculas o minúsculas antes de la comparación en el bucle for. Es útil cuando se trata de palíndromos como AVva, donde los caracteres mezclan mayúsculas y minúsculas.

Invierta la cadena para verificar si una cadena es un palíndromo en Java

Considere que tenemos la cadena aabcvbaa. Primero invirtamos la cadena. La cadena resultante será aabvcbaa.

El último carácter de la cadena original se convierte en el primer carácter de la cadena invertida. El penúltimo carácter de la cadena original se convierte en el segundo carácter de la cadena invertida, y así sucesivamente.

Ahora, podemos comparar las dos cadenas carácter por carácter para verificar si la cadena es un palíndromo. Si ocurre algún desajuste, la cadena no es un palíndromo, y podemos devolver false, notificando al usuario que la cadena no es un palíndromo.

Pero, si no ocurre ningún desajuste, podemos devolver true, diciendo que la cadena es un palíndromo. En este caso, estamos creando una nueva cadena invertida en lugar de usar dos punteros en la misma cadena (vea la demostración).

A veces, no se nos permite usar las funciones integradas proporcionadas en Java. Por lo tanto, no utilizaremos el método reverse() de las API de Java.

Escribiremos nuestra función para invertir la cadena.

public class Solution {
  static boolean Sol(String s)

  {
    // reverse the string
    StringBuilder reversed_str = new StringBuilder();
    char[] newArray = s.toCharArray();
    for (int index = newArray.length - 1; index >= 0; index--) {
      reversed_str.append(newArray[index]);
    }

    // comparing the original string with the reversed string
    return (reversed_str.toString()).equals(s);
  }

  public static void main(String[] args) {
    String s = "raceCAR";

    // Convert the string to the lowercase
    s = s.toLowerCase();

    if (Sol(s))
      System.out.print("Yes, this string is a palindrome.");

    else
      System.out.print("No, it isn't a palindrome.");
  }
}

Producción :

Yes, this string is a palindrome.

Veamos rápidamente lo que sucede dentro de la función Sol. Primero cambiamos la cadena a una matriz y luego usamos esto para invertir la cadena.

Luego, comparamos la cadena invertida con la cadena original letra por letra.

1. Clase StringBuilder: la clase de cadena en Java crea cadenas inmutables, es decir, cadenas inmutables. Aquí, queremos crear una cadena, reversed_str, que es mutable para agregarle caracteres. La clase StringBuilder en Java nos ayuda a crear cadenas mutables.
2. Método toCharArray: Dado que queremos comparar la cadena original y la inversa carácter por carácter, utilizamos el método toCharArray() para convertir la cadena en una serie de caracteres. Almacenamos el resultado en el array newArray.
3. Método append(): después de cambiar la cadena original a una matriz de caracteres, utilícelo para hacer la cadena invertida. Para esto, recorremos la matriz de caracteres desde el final y seguimos agregando los caracteres en la cadena reversed_str usando el método append().
4. Método toString(): Lo cambiamos a una cadena nuevamente usando el método toString() después de hacer la cadena invertida. Hacemos esto porque podemos comparar dos cadenas simplemente usando el método equals().

5. Método equals(): Por último, comparamos la cadena original s con la cadena invertida reversed_str. Para ello, podemos utilizar el método equals(), que devuelve true si todos los caracteres de la cadena coinciden.

Podemos lograr lo mismo con facilidad si usamos el método reverse() de las API de Java: StringBuilder y StringBuffer, como se muestra a continuación.

// Check if a string is a palindrome
// Java program

public class Solution {
  static boolean Sol(String s)

  { // Using the stringbuilder API
    StringBuilder newString = new StringBuilder(s);
    StringBuilder rev_str = newString.reverse();
    return (rev_str.toString()).equals(s);
  }

  public static void main(String[] args) {
    String s = "raceCAR";

    // Convert the string to the lowercase
    s = s.toLowerCase();

    if (Sol(s))
      System.out.print("Yes, it is a palindrome.");

    else
      System.out.print("No, it is not a palindrome.");
  }
}

Producción :

Yes, it is a palindrome.

Tenga en cuenta que cuando usamos la API StringBuilder, no necesitamos crear matrices de caracteres o invertir la cadena usando un bucle for. Este método es limpio y simple.

Para obtener más información sobre la clase StringBuilder, consulte esta documentación.

También podemos usar la API StringBuilder, como se muestra a continuación.

public class CheckPalindrome {
  static boolean Sol(String s)

  { // Using the stringbuffer API
    StringBuffer str = new StringBuffer(s);
    StringBuffer rev_str = str.reverse();
    return (rev_str.toString()).equals(s);
  }

  public static void main(String[] args) {
    String s = "raceCAR";

    // Convert the string to the lowercase
    s = s.toLowerCase();

    if (Sol(s))
      System.out.print("Yes, it is a palindrome.");

    else
      System.out.print("No, it is not a palindrome.");
  }
}

Producción :

Yes, it is a palindrome.

Quizás se pregunte qué hace que las clases StringBuilder y StringBuffer sean diferentes porque el código parece idéntico.

La clase StringBuffer permite que solo un subproceso llame a este método a la vez. Está sincronizado.

Por otro lado, el método StringBuilder puede ser llamado por más de un solo hilo simultáneamente. No está sincronizado.

Sin embargo, la clase StringBuilder es más eficiente que la clase StringBuffer. Para saber más sobre la clase StringBuffer, consulte esta documentación.

Use recursividad para verificar si una cadena es un palíndromo en Java

Podemos llamar recursivamente a la función Sol para comprobar si una cadena es un palíndromo. La idea básica es usar la recursividad para iterar sobre la cadena.

public class Solution {
  static boolean Sol(String s)

  {
    s = s.toLowerCase();
    return RecursePal(s, 0, s.length() - 1);
  }

  static boolean RecursePal(String s, int f, int b) {
    if (f == b) {
      return true;
    }
    if ((s.charAt(f)) != (s.charAt(b))) {
      return false;
    }
    if (f < b + 1) {
      return RecursePal(s, f + 1, b - 1);
    }
    return true;
  }

  public static void main(String[] args) {
    String s = "raceCAR";

    // Convert the string to the lowercase
    s = s.toLowerCase();

    if (Sol(s))
      System.out.print("Yes");

    else
      System.out.print("No");
  }
}

Producción :

Yes

Aquí, definimos una función, RecursePal. Pasamos la cadena s, el índice del primer carácter como f, y el índice del último carácter como b como argumentos.

Luego, verificamos si el carácter en f es el mismo que en b. Si es así, devolvemos true.

De lo contrario, devolvemos false. Por último, volvemos a llamar a la función RecursePal para repetir este proceso para toda la cadena.

Cada vez que llamamos recursivamente a esta función, incrementamos el índice f y decrementamos el índice b en uno.

Conclusión

En este tutorial, vimos las diferentes formas en Java para verificar si una cadena es un palíndromo o no.

Aprendimos a usar dos punteros para recorrer la cadena en ambos sentidos. También vimos cómo verificar si una cadena es un palíndromo al invertir la cadena y usar la recursividad en Java.