Palindrome & Java

Einleitung

Zu einen der ersten Projekte, die man beim Lernen von Programmiersprachen programmiert, ist ein "Palindrom-Prüfer". Ein Benutzer soll die Möglichkeit haben ein Wort (oder sogar einen ganzen Satz) einzugeben und dann soll das Programm überprüfen, ob es sich bei der Eingabe um ein Palindrom handelt. Genau das wird im Folgenden mit Java behandelt, nur etwas unnötig kompliziert.

Main.java

Innerhalb der Main.java-Datei werden nun die nötigen Packete eingebunden:

import java.util.HashMap;
import java.util.Scanner; // for user-input

Dann können wir auch schon die Main-Klasse und die main-Funktion definieren:

public class Main {
    public static void main(String[] args) {}
}

Der Benutzer soll nun die Möglichkeit haben sein Wort als Parameter in der args-Variable mitzuliefern, muss natürlich zuerst überprüft werden, ob überhaupt noch ein weiterer Parameter mitgeliefert wurde:

String word = "";
if (args.length >= 1) {
    word = args[0];
}

Sollte das nicht der Fall sein, kann der Benutzer doch noch sein Wort angeben:

else {
    Scanner scanner_obj = new Scanner(System.in);
    System.out.print("Enter the word: ");
    word = scanner_obj.nextLine();
    scanner_obj.close();
}

Damit der Code übersichtlich bleibt, wird eine separate Funktion check_word definiert, die als Parameter die String-Variable word mitgeliefert bekommt und einen Integer als Rückgabewert hat:

int status = check_word(word);
if (status == 1) {
    System.out.println("The word '"+word+"' is a palindrome.");
} else if (status == 0) {
    System.out.println("The word '"+word+"' is not a palindrome!");
} else {
    System.out.println("Couldn't determine if it's a palindrome or not!");
}

Da der Benutzer nun auch Wörter wie 'Otto' oder 'oTtO' eingeben kann, können wir nicht einfach die Buchstaben vergleichen. Davor müssen also noch die Buchstaben entweder in lowercase oder uppercase umgewandelt werden. Hierfür gäbe es eigentlich bereits die Funktion toUpperCase(), aber zur Übung verkompliziere ich es hier:

static char[] make_word_uppercase(String word) {
    char[] letters = word.toCharArray();
    HashMap<Character,Character> lower_to_upper_hashmap = new HashMap();
    char[] lower_alphabet = "abcdefghijklmnopqrstuvwxyz".toCharArray();
    char[] upper_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
    for (int i = 0; i < lower_alphabet.length; i++) {
        lower_to_upper_hashmap.put(lower_alphabet[i],upper_alphabet[i]);
    }
    char[] new_word = letters;
    for (int i = 0; i < word.length(); i++) {
        if ((int)letters[i] >= 97 && (int)letters[i] <= 122) { // ASCII Codes of 'a' and 'z'
            new_word[i] = lower_to_upper_hashmap.get(letters[i]);
        } else {
            new_word[i] = letters[i];
        }
    }
    return new_word;
}

Wessen Stirn zuvor gerunzelt wurde, weshalb hier eine HashMap benutzt wurde: Deswegen. Da die check_word-Funktion nun einen String erhalten hat und ich lieber mit char-arrays arbeite, wird nun noch die Funktion toCharArray() benutzt. Innerhalb der for-Schleife wird der ASCII-Code von jedem Zeichen im char-array überprüft, ob sich der Integer zwischen 96 und 123 befindet. Das sind nämlich die ASCII-Codes vom Buchstaben 'a' und 'z'. Wird dann beispielsweise ein 'a' gefunden, wird in einem neuen char-array statt dem Buchstaben 'a' ein 'A' eingesetzt. Befindet sich das derzeitige Zeichen nicht im lower_alphabet, wird das Zeichen unverändert in new_word gespeichert. Nun können wir zur eigentlichen Funktion check_word kommen:

static int check_word(String this_word) {
    char[] word = make_word_uppercase(this_word);
    int status = 1; // for true
    for (int i = 0; i < word.length; i++) {
        try {
            if (word[i] != word[word.length-1-i]) {
                status = 0; // for false
                break;
            }
        } catch (Exception e) {
            System.out.println("An error occured: "+e.toString());
            status = -1; // for unknown
            break;
        }
    }
    return status;
}

Innerhalb der for-Schleife wird lediglich noch überprüft, ob beispielsweise das Wort an Stelle 0 dem entspricht, was an Stelle 'Länge des Wortes'-1 steht. Das -1, da hier mit Indizes gearbeitet wird. Man könnte diesen Code noch insofern verbessern, dass beispielsweise Leerzeichen gefiltert werden. Verbesserungsvorschläge sind erwünscht und dürfen gerne in den Kommentaren propagiert werden.

Der vollständige Code: GitHub/Pulsar7