Vérifier les palindromes en Java

Introduction

Dans ce laboratoire, nous allons apprendre à vérifier si une chaîne de caractères est un palindrome ou non en Java. Un palindrome est une chaîne de caractères qui se lit de la même manière dans les deux sens.

Utilisation de deux pointeurs pour vérifier les palindromes

La première méthode que nous allons implémenter est l'approche des deux pointeurs. Nous allons créer une méthode appelée isPalindrome qui prend une chaîne de caractères en entrée et renvoie une valeur booléenne indiquant si la chaîne est un palindrome ou non.

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;
    }
}

La méthode isPalindrome utilise deux pointeurs, start et end, qui partent respectivement du début et de la fin de la chaîne. La boucle s'exécute jusqu'à ce que les deux pointeurs se rencontrent au milieu.

À chaque itération, nous comparons les caractères aux emplacements des pointeurs start et end. Si ils ne sont pas égaux, nous renvoyons false. Si ils le sont, nous mettons à jour les pointeurs pour vérifier le prochain ensemble de caractères de la chaîne.

Pour tester notre méthode, nous pouvons ajouter une méthode main et appeler la méthode isPalindrome avec diverses chaînes de caractères en entrée.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implémentation de la méthode isPalindrome
    }

    public static void main(String[] args) {
        System.out.println("Est-ce que 'racecar' est un palindrome? " + isPalindrome("racecar"));
        System.out.println("Est-ce que 'hello' est un palindrome? " + isPalindrome("hello"));
    }
}

Utilisation de la récursivité pour vérifier les palindromes

La prochaine méthode que nous allons implémenter est l'approche récursive. Nous allons créer une nouvelle méthode appelée isPalindromeRecursive qui prend la chaîne, l'index de départ et l'index de fin en entrée.

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 pour les méthodes isPalindrome et isPalindromeRecursive
    }
}

La méthode isPalindromeRecursive utilise la récursivité pour vérifier si la chaîne est un palindrome ou non. Nous avons deux cas de base :

1. Si l'index start est supérieur ou égal à l'index end, cela signifie que nous avons vérifié tous les caractères de la chaîne et qu'ils correspondent, donc nous renvoyons true.
2. Si les caractères aux indices start et end ne sont pas égaux, nous renvoyons false.

Si aucun des cas de base n'est rencontré, nous appelons isPalindromeRecursive à nouveau avec les indices mis à jour.

Nous pouvons maintenant tester notre méthode récursive en l'appelant à l'intérieur de la méthode main.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implémentation de la méthode isPalindrome
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implémentation de la méthode isPalindromeRecursive
    }

    public static void main(String[] args) {
        System.out.println("Est-ce que 'racecar' est un palindrome? " + isPalindromeRecursive("racecar", 0, 6));
        System.out.println("Est-ce que 'hello' est un palindrome? " + isPalindromeRecursive("hello", 0, 4));
    }
}

Inverser la chaîne pour vérifier les palindromes

La dernière méthode que nous allons implémenter est l'approche d'inversion de chaîne. Nous allons créer une nouvelle méthode appelée isPalindromeReverse qui prend une chaîne de caractères en entrée.

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implémentation de la méthode isPalindrome
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implémentation de la méthode isPalindromeRecursive
    }

    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 pour les méthodes isPalindrome et isPalindromeRecursive
        System.out.println("Est-ce que 'racecar' est un palindrome? " + isPalindromeReverse("racecar"));
        System.out.println("Est-ce que 'hello' est un palindrome? " + isPalindromeReverse("hello"));
    }
}

La méthode isPalindromeReverse crée une nouvelle chaîne appelée reversed et la remplit en parcourant la chaîne d'entrée de la fin au début. Nous renvoyons ensuite true si les deux chaînes sont égales en ignorant la casse.

Nous pouvons tester la méthode en ajoutant un appel à isPalindromeReverse dans la méthode main.

Utiliser les flux Java pour vérifier les palindromes

Enfin, nous allons utiliser l'API des flux Java pour vérifier les palindromes. Nous allons créer une nouvelle méthode appelée isPalindromeStream qui prend une chaîne de caractères en entrée.

import java.util.stream.IntStream;

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        // Implémentation de la méthode isPalindrome
    }

    public static boolean isPalindromeRecursive(String str, int start, int end) {
        // Implémentation de la méthode isPalindromeRecursive
    }

    public static boolean isPalindromeReverse(String str) {
        // Implémentation de la méthode isPalindromeReverse
    }

    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 pour les méthodes isPalindrome et isPalindromeRecursive
        System.out.println("Est-ce que 'racecar' est un palindrome? " + isPalindromeStream("racecar"));
        System.out.println("Est-ce que 'hello' est un palindrome? " + isPalindromeStream("hello"));
    }
}

La méthode isPalindromeStream utilise la classe IntStream pour générer une plage d'indices que nous pouvons utiliser pour comparer les caractères dans la chaîne.

Nous utilisons la méthode noneMatch pour renvoyer true si aucun des caractères ne viole la condition selon laquelle les ith et n-i-1th caractères sont égaux, où n est la longueur de la chaîne et i est l'index.

Nous pouvons tester la méthode en ajoutant un appel à isPalindromeStream dans la méthode main.

Sommaire

Dans ce laboratoire, nous avons appris à vérifier si une chaîne de caractères donnée est un palindrome ou non en Java. Nous avons implémenté quatre méthodes différentes pour accomplir cette tâche :

1. Approche des deux pointeurs
2. Approche récursive
3. Approche d'inversion de la chaîne
4. Approche des flux Java

Maintenant que vous comprenez ces méthodes, vous pouvez les utiliser pour résoudre des problèmes plus complexes!