Palindrome-Prüfung in Java

Einführung

In diesem Lab werden wir lernen, wie man in Java überprüft, ob ein String ein Palindrom ist oder nicht. Ein Palindrom ist ein String, der sowohl von vorne nach hinten als auch von hinten nach vorne gelesen gleich ist.

Verwendung von zwei Zeigern zum Überprüfen auf Palindrome

Die erste Methode, die wir implementieren werden, ist der Zwei-Zeiger-Ansatz. Wir werden eine Methode namens isPalindrome erstellen, die einen String als Eingabe nimmt und einen booleschen Wert zurückgibt, der angibt, ob der String ein Palindrom ist oder nicht.

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

Die isPalindrome-Methode verwendet zwei Zeiger, start und end, die jeweils am Anfang und am Ende des Strings beginnen. Die Schleife läuft, bis die beiden Zeiger sich in der Mitte treffen.

In jeder Iteration vergleichen wir die Zeichen an den start- und end-Zeigern. Wenn sie nicht gleich sind, geben wir false zurück. Wenn sie es sind, aktualisieren wir die Zeiger, um die nächste Zeichengruppe im String zu überprüfen.

Um unsere Methode zu testen, können wir eine main-Methode hinzufügen und die isPalindrome-Methode mit verschiedenen Eingabestrings aufrufen.

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

Verwendung von Rekursion zum Überprüfen auf Palindrome

Die nächste Methode, die wir implementieren werden, ist der rekursive Ansatz. Wir werden eine neue Methode namens isPalindromeRecursive erstellen, die den String, den Startindex und den Endindex als Eingabe nimmt.

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

Die isPalindromeRecursive-Methode verwendet Rekursion, um zu überprüfen, ob der String ein Palindrom ist oder nicht. Wir haben zwei Basisfälle:

1. Wenn der start-Index größer oder gleich dem end-Index ist, bedeutet dies, dass wir alle Zeichen im String überprüft haben und sie übereinstimmen, also geben wir true zurück.
2. Wenn die Zeichen an den start- und end-Indices nicht gleich sind, geben wir false zurück.

Wenn keiner der Basisfälle zutrifft, rufen wir isPalindromeRecursive erneut mit den aktualisierten Indices auf.

Wir können unsere rekursive Methode jetzt testen, indem wir sie innerhalb der main-Methode aufrufen.

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

Umkehren des Strings zum Überprüfen auf Palindrome

Die letzte Methode, die wir implementieren werden, ist der String-Umkehr-Ansatz. Wir werden eine neue Methode namens isPalindromeReverse erstellen, die einen String als Eingabe nimmt.

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

Die isPalindromeReverse-Methode erstellt einen neuen String namens reversed und füllt ihn auf, indem sie durch den Eingabestring von hinten nach vorne iteriert. Wir geben dann true zurück, wenn die beiden Strings gleich sind, wobei die Groß-/Kleinschreibung ignoriert wird.

Wir können die Methode testen, indem wir einen Aufruf von isPalindromeReverse in der main-Methode hinzufügen.

Verwendung von Java Streams zum Überprüfen auf Palindrome

Schließlich werden wir die Java Streams-API verwenden, um auf Palindrome zu überprüfen. Wir werden eine neue Methode namens isPalindromeStream erstellen, die einen String als Eingabe nimmt.

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

Die isPalindromeStream-Methode verwendet die IntStream-Klasse, um einen Bereich von Indizes zu generieren, mit denen wir die Zeichen im String vergleichen können.

Wir verwenden die noneMatch-Methode, um true zurückzugeben, wenn kein Zeichen die Bedingung verletzt, dass das ith und das n-i-1th Zeichen gleich sind, wobei n die Länge des Strings und i der Index ist.

Wir können die Methode testen, indem wir einen Aufruf von isPalindromeStream in der main-Methode hinzufügen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java überprüft, ob ein gegebener String ein Palindrom ist oder nicht. Wir haben vier verschiedene Methoden implementiert, um diese Aufgabe zu lösen:

1. Zwei-Zeiger-Ansatz
2. Rekursiver Ansatz
3. String-Umkehr-Ansatz
4. Java Streams-Ansatz

Jetzt, da Sie diese Methoden verstehen, können Sie sie verwenden, um komplexere Probleme zu lösen!