import java.util.Scanner;

/**
 * Diese Klasse enthaelt Uebungsaufgaben fuer den Umgang mit Strings. 
 * 
 */
public class Stringuebungen {

    /**
     * Diese Methode demonstriert grundlegend das Anlegen, Verketten 
     * und Ausgeben von Strings. Lest sie aufmerksam und durch
     * probiert sie aus, bis ihr alles verstanden habt.
     */
    public static void basics_Demo() {
        // So kann man eine String-Instanz anlegen: 
        String s1 = new String("Hallo!");

        // Die folgende Kurzschreibweise ist aber allgemein ueblich: 
        String s2 = "Guten Morgen!";


        // Erst nachdenken, dann ausprobieren: Was geben diese Zeilen aus?
        System.out.println("Erster Test");
        System.out.println(s1);

        // Mit dem + kann man Strings ganz einfach verketten:
        System.out.println("s1 ist " + s1);
        System.out.println("s2 ist " + s2);


        //  String-Instanzen koennen nach der Instanziierung nie wieder 
        // veraendert werden (man sagt englisch "Strings sind immutable")
        // -- die Referenzen allerdings schon:
        s1 = s2;  // s1 zeigt jetzt auf eine andere String-Instanz

        // Man kann auch Variablen anderer Typen mit Strings verketten:
        int x = 44;
        System.out.println(x);
        System.out.println("Die Variable x hat den Wert " + x);

        // Dabei kann man nicht mit dem int anfangen; vor dem + muss immer 
        // ein String stehen, notfalls ein leerer:
        System.out.println("" + x + " ist der Wert von x.");

        // Von der Tastatur einzulesen ist leider recht hakelig: Ganz
        // oben in der Datei muss "import java.util.Scanner;" stehen (s.o.),
        // dann braucht man (einmal) eine Scanner-Instanz...:
        Scanner tastaturleser = new Scanner(System.in);
        // und dann erst kann man mit dem Scanner etwas von der Tastatur lesen:
        System.out.println("Bitte gib' einen kurzen Text ein: ");
        String s3;
        s3 = tastaturleser.nextLine();

        System.out.println("Deine Eingabe lautet \"" + s3 + "\"");

    }

    /**
     * Diese Methode demonstriert die Benutzung der String-Methoden
     * length(), indexOf(), charAt(), toUpperCase() und substring().
     * Lest sie aufmerksam durch und probiert aus bis ihr alles 
     * verstanden habt.
     */
    public static void stringMethodenDemo() {
        ///////////////////////////////////////////////////
        ///////////// Die Methode length() ////////////////
        // ermittelt die Laenge eines Strings:
        String s = "Informatik";
        System.out.println(s + " besteht aus " + s.length() + " Zeichen.");
        System.out.println("Baden-Wuerttemberg".length());
        System.out.println();

        ///////////////////////////////////////////////////
        ///////////// Die Methode indexOf() ////////////////
        // ermittelt den Index der ersten Fundstelle, an 
        // der ein String innerhalb eines laengeren Strings vorkommt. 
        // Achtung: die Indizes beginnen bei 0, nicht bei 1 (wie bei Arrays)
        String text = "Barbara mag aber Rhabarber statt Gelaber!";

        // Erst ueberlegen, dann testen: Welche Fundstelle wird ausgegeben?
        String gesucht = "bar";
        int index = text.indexOf(gesucht);
        System.out.println("In " + text + " steht " + gesucht 
            + " bei Index " + index);

        gesucht = "ab";
        index = text.indexOf(gesucht);
        System.out.println("In " + text + " steht " + gesucht 
            + " bei Index " + index);

        gesucht = "ber";
        index = text.indexOf(gesucht);
        System.out.println("In " + text + " steht " + gesucht 
            + " bei Index " + index);

        // Man kann die Suche auch weiter hinten beginnen, hier bei 15:
        gesucht = "ber";
        index = text.indexOf(gesucht, 15);
        System.out.println("In " + text + " steht " + gesucht 
            + " bei Index " + index);
        System.out.println();

        ///////////////////////////////////////////////////
        ///////////// Die Methode charAt() ////////////////
        // pickt einen einzelnen Buchstaben ("character") aus einem String. 
        // Der Java-Typ char ist dabei ein primitiver Typ (keine Klasse!).
        text = "if-Schleifen gibt es nicht!";
        char c = 'h';
        char buchstabe = text.charAt(0);
        System.out.println(buchstabe);

        // Erst nachdenken, dann testen: Was wird ausgegeben?
        System.out.println(text.charAt(3));

        System.out.println(text.charAt(text.length() - 4));
        System.out.println();

        ///////////////////////////////////////////////////
        ///////// Die Methoden toUpperCase() und toLowerCase 
        // erzeugen einen neuen String, der nur Gross- (bzw. Klein-)
        // buchstaben enthaelt:
        System.out.println("Aus " + text + " wird " + text.toLowerCase());
        System.out.println("Aus " + text + " wird " + text.toUpperCase());  
        System.out.println();

        ///////////////////////////////////////////////////
        ///////// Die Methoden subString() schneidet aus einem 
        // String einen Teil heraus. Die Angabe von Startindex und
        // dem (nicht mehr enthaltenen!) Endindex ist allerdings 
        // gewoehnungsbeduerftig:
        System.out.print(text + "\nenthaelt ab Index 4 bis 7: ");
        System.out.println(text.substring(4, 7));
    }

    /**
     * Zaehlt die Vorkommen eines Buchstabens innerhalb eines Textes.
     * @param text zu durchsuchender Text
     * @param z Buchstabe, nach dem gesucht wird
     * @return Zahl der Vorkommen von z in text
     */
    public static int anzahlVorkommen(String text, char z) {
        /*# Geht mit einer Schleife den gesamten String durch;
         * erhöhe den Zaehler jedesmal, wenn  das Zeichen
         * im String vorkommt; gebe dann den Wert des Zaehlers zurueck. */ 

        int anzahl = 0;


        return anzahl;
    }


    /**
     * Dreht den uebergebenen String herum.
     * Aus GEWINNER wird also RENNIWEG.
     * 
     * @param text umzudrehender String
     * @return den umgedrehten String
     */
    public static String rueckwaerts(String text) {
        /*#Dies kann auf verschiedene Arten gelößt werden.
         * Eine Möglichkeit ist, du gehst mit einer Schleife 
         * rueckwaerts durch den String 
         * das geht z.B. mit for(int i=s.length()-1; i>=0; i--) und
         * haenge sie seine Buchstaben an den ergebnis-String an.
         */

        String ergebnis = "";


        return ergebnis;
    }

    /**
     * Ermittelt, ob ein Text ein Palindrom ist.
     * Ein Text ist ein Palindrom, wenn er rueckwaerts wie vorwaerts
     * gelesen das gleiche ergibt. Beispiele sind ANNA, OTTO, RENTNER, RELIEFPFEILER 
     * oder auch als Palindromsatz ERIKAFEUERTNURUNTREUEFAKIRE.
     * 
     * Das Wort Bob gilt wegen der Gross-/Kleinschreibung
     * hier NICHT als Palindrom.
     * 
     * @param text Text, der untersucht werden soll.
     * @return true, wenn der Text ein Palindrom ist; false sonst.
     */
    public static boolean istPalindrom(String text ) {
        /*# Diese Aufgabe kann auf verschiedene Arten geloest werden. 
         * Eine nutzt auf elegante Weise anderen Code. Eine andere geht so: 
         * Durchlaufe den Text in einer Schleife und vergleiche den
         * ersten mit dem letzten Buchstaben (im naechsten Durchlauf dann den
         * zweiten mit dem vorletzten usw.). 
         */


        return true;
    }

    
    
    
    /**
     * Prueft, ob zwei Woerter Anagramme voneinander sind.
     * 
     * Anagramme nennt man Woerter (oder Texte), die durch 
     * Umordnung ihrer Buchstaben auseinander hervorgehen. 
     * Folgende Wort- bzw. Textpaare sind beispielsweise 
     * Anagramme voneinander:<p>
     * Leo / Oel<p>
     * shit / hits / this<p>
     * SAU / USA<p>
     * ABITURE / BAU TIER<p>
     * STAUFENS /  FAN-TUSSE<p>
     * Frodos Ehe / Sehr doofe<p>
     * 
     * Zwei Saetze gelten auch dann als Anagramme, wenn dafür 
     * Leer- und Satzzeichen sowie Kleinschreibung ignoriert 
     * werden muessen wie bei "rauschen" / "Hase nur C".
     * 
     * @param wort1 Der erste Text.
     * @param wort2 Der zweite Text.
     * @return ob die beiden Texte Anagramme voneinander sind.
     */
    public static boolean sindAnagramme(String wort1, String wort2 ) {
        /*# Mache dir klar, dass es nur auf die Haeufigkeit der 
         * Buchstaben ankommt. Und dann mach dir keine 
         * unnoetige Arbeit, sondern benutze fertigen Code. 
         */

        boolean ergebnis = true;


        return ergebnis;
    }
    

    /**
     * Für Experten: Die Caesar-Chiffre
     * Die Funktion chiffriert einen Klartext mit der Caesar-Chiffre und
     * dem angegebenen Schluessel. 
     * Der Klartext wird  um "schluessel" Stellen im Alphabet 
     * weitergeschoben. Mit dem Schluessel 3 wird also 
     * 
     * aus "ABC" der Geheimtext DEF 
     * aus "VWXYZ" der Geheimtext YZABC   
     * aus "INFO" der Geheimtext LQIR
     * 
     * Der Einfachheithalber dürft ihr annehmen, dass der zu verschlüsselnde
     * Text "normalisiert" ist, d.h. nur Großbuchstaben enthält.
     * 
     * @param klartext zu verschluesselnder Klartext
     * @param schluessel Verschiebung im Alphabet (nach rechts)
     * @return den verschluesselten Text (Geheimtext).
     */
    public static String caesarChiffrieren(String klartext, int schluessel) {
        /*# Es gibt verschiedene Moeglichkeiten, die Verschiebung 
         * umzusetzen; eine besteht darin, alle Buchstaben einzeln in 
         * int-Werte umzurechnen. Man kann char-Werte mit einer Zuweisung wie
         * int zahl = (int) charVariable;
         * ganz einfach in int-Werte umwandeln. Dann rechnet man die eigentliche 
         * Caesar-Verschiebung aus und wandelt mit
         * char c = (char) intVariable;
         * zurueck in Buchstaben. 
         * 
         * Aber Achtung: 'A' hat nicht den Zahlenwert 0! 
         * Finde zuerst raus, welchen Zahlenwert A hat.
         */

        String geheimtext = "";


        return geheimtext;
    }

    

    
}