Prüfen Sie, ob ein String ein Palindrom ist

Überprüfen Sie, ob eine Zeichenfolge ein Palindrom ist

1. Einführung

In diesem Artikel werden wir sehen, wie wir mithilfe von Java überprüfen können, ob ein bestimmtesString ein Palindrom ist.

A palindrome is a word, phrase, number, or other sequences of characters which reads the same backward as forward, wie "Frau" oder "Rennwagen".

2. Lösungen

In den folgenden Abschnitten werden die verschiedenen Möglichkeiten zum Überprüfen untersucht, ob ein bestimmtesString ein Palindrom ist oder nicht.

2.1. Ein einfacher Ansatz

Wir können gleichzeitig beginnen, die angegebenenstring zeichenweise vorwärts und rückwärts zu iterieren. Wenn eine Übereinstimmung vorliegt, wird die Schleife fortgesetzt. Andernfalls wird die Schleife beendet:

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. String umkehren

Es gibt einige verschiedene Implementierungen, die zu diesem Anwendungsfall passen: Wir können die API-Methoden aus den KlassenStringBuilder undStringBuffer verwenden, wenn wir nach Palindromen suchen, oder wir können dieString ohne diese umkehren Klassen.

Schauen wir uns zunächst die Code-Implementierungen ohne die Hilfs-APIs an:

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

Im obigen Snippet iterieren wir einfach die angegebenenString vom letzten Zeichen und hängen jedes Zeichen an das nächste Zeichen bis zum ersten Zeichen an, wodurch die angegebenenString. umgekehrt werden

Schließlich testen wir die Gleichheit zwischen den angegebenenString und den umgekehrtenString.

Das gleiche Verhalten könnte mit API-Methoden erreicht werden.

Sehen wir uns eine kurze Demonstration an:

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

Im Code-Snippet rufen wir die Methodereverse() aus der APIStringBuilder undStringBuffer auf, um die angegebenenString umzukehren und auf Gleichheit zu testen.

2.3. Verwenden derStream API

Wir können auch einIntStream verwenden, um eine Lösung bereitzustellen:

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

Im obigen Snippet überprüfen wir, ob keines der Zeichenpaare an jedem Ende derString diePredicate-Bedingung erfüllt.

2.4. Rekursion verwenden

Rekursion ist eine sehr beliebte Methode, um diese Art von Problemen zu lösen. In dem gezeigten Beispiel iterieren wir rekursiv die angegebenenString und testen, um herauszufinden, ob es sich um ein Palindrom handelt oder nicht:

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. Fazit

In diesem kurzen Tutorial haben wir gesehen, wie man herausfindet, ob ein gegebenesString ein Palindrom ist oder nicht.

Wie immer sind die Codebeispiele für diesen Artikelover on GitHub verfügbar.