278 lines
9.9 KiB
Java
278 lines
9.9 KiB
Java
import java.util.Scanner;
|
|
|
|
/**
|
|
* Diese Klasse enthält Übungsaufgaben für 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 üblich:
|
|
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 können nach der Instanziierung nicht mehr
|
|
// verändert 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.");
|
|
|
|
// Um von Tastatur einzulesenmuss ganz
|
|
// oben in der Datei "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 Länge eines Strings:
|
|
String s = "Informatik";
|
|
System.out.println(s + " besteht aus " + s.length() + " Zeichen.");
|
|
System.out.println("Baden-Württemberg".length());
|
|
System.out.println();
|
|
|
|
///////////////////////////////////////////////////
|
|
///////////// Die Methode indexOf() ////////////////
|
|
// ermittelt den Index der ersten Fundstelle, an
|
|
// der ein String innerhalb eines längeren Strings vorkommt.
|
|
// Achtung: die Indizes beginnen bei 0, nicht bei 1 (wie bei Arrays)
|
|
String text = "Barbara mag aber Rhabarber statt Gelaber!";
|
|
|
|
// Erst überlegen, 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 enthält:
|
|
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
|
|
// gewöhnungsbedürftig:
|
|
System.out.print(text + "\nenthält ab Index 4 bis 7: ");
|
|
System.out.println(text.substring(4, 7));
|
|
}
|
|
|
|
/**
|
|
* Zählt die Vorkommen eines Buchstabens innerhalb eines Textes.
|
|
* @param text der zu durchsuchender Text
|
|
* @param z der Buchstabe, nach dem gesucht wird
|
|
* @return Zahl Anzahl, wie oft z in text vorkommt
|
|
*/
|
|
public static int anzahlVorkommen(String text, char z) {
|
|
/*# Geh mit einer Schleife den gesamten String durch;
|
|
* erhöhe den Zähler jedesmal, wenn das Zeichen
|
|
* im String vorkommt; gebe dann den Wert des Zählers zurück. */
|
|
|
|
int anzahl = 0;
|
|
|
|
|
|
return anzahl;
|
|
}
|
|
|
|
|
|
/**
|
|
* Dreht den übergebenen 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öst werden.
|
|
* Eine Möglichkeit ist, du gehst mit einer Schleife
|
|
* rückwärts durch den String
|
|
* das geht z.B. mit for(int i=s.length()-1; i>=0; i--) und
|
|
* hänge die Buchstaben an den ergebnis-String an.
|
|
*/
|
|
|
|
String ergebnis = "";
|
|
|
|
|
|
return ergebnis;
|
|
}
|
|
|
|
/**
|
|
* Ermittelt, ob ein Text ein Palindrom ist.
|
|
* Ein Text ist ein Palindrom, wenn er rückwärts wie vorwärts
|
|
* 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 gelöst 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 nächsten Durchlauf dann den
|
|
* zweiten mit dem vorletzten usw.).
|
|
*/
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Prüft, ob zwei Wörter Anagramme voneinander sind.
|
|
*
|
|
* Anagramme nennt man Wörter (oder Texte), die durch
|
|
* Umordnung ihrer Buchstaben auseinander hervorgehen.
|
|
* Folgende Wort- bzw. Textpaare sind beispielsweise
|
|
* Anagramme voneinander:
|
|
* Leo / Oel
|
|
* shit / hits / this
|
|
* SAU / USA
|
|
* ABITURE / BAU TIER
|
|
* STAUFENS / FAN-TUSSE
|
|
* Frodos Ehe / Sehr doofe
|
|
*
|
|
* Zwei Sätze gelten auch dann als Anagramme, wenn dafür
|
|
* Leer- und Satzzeichen sowie Kleinschreibung ignoriert
|
|
* werden müssen 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 Häufigkeit der
|
|
* Buchstaben ankommt. Und dann mach dir keine
|
|
* unnötige Arbeit, sondern benutze fertigen Code.
|
|
*/
|
|
|
|
boolean ergebnis = true;
|
|
|
|
|
|
return ergebnis;
|
|
}
|
|
|
|
|
|
/**
|
|
* Für Experten: Die Cäsar-Chiffre
|
|
* Die Funktion chiffriert einen Klartext mit der Cäsar-Chiffre und
|
|
* dem angegebenen Schlüssel.
|
|
* Der Klartext wird um "Schlüssel" Stellen im Alphabet
|
|
* weitergeschoben. Mit dem Schlüssel 3 wird also
|
|
*
|
|
* aus "ABC" der Geheimtext DEF
|
|
* aus "VWXYZ" der Geheimtext YZABC
|
|
* aus "INFO" der Geheimtext LQIR
|
|
*
|
|
* Der Einfachheit halber dürft ihr annehmen, dass der zu verschlüsselnde
|
|
* Text "normalisiert" ist, d.h. nur Großbuchstaben enthält.
|
|
*
|
|
* @param klartext zu verschlüsselnder Klartext
|
|
* @param schluessel Verschiebung im Alphabet (nach rechts)
|
|
* @return den verschlüsselten Text (Geheimtext).
|
|
*/
|
|
public static String caesarChiffrieren(String klartext, int schluessel) {
|
|
/*# Es gibt verschiedene Möglichkeiten, 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
|
|
* Cäsar-Verschiebung aus und wandelt mit
|
|
* char c = (char) intVariable;
|
|
* zurück in Buchstaben.
|
|
*
|
|
* Aber Achtung: 'A' hat nicht den Zahlenwert 0!
|
|
* Finde zuerst raus, welchen Zahlenwert A hat.
|
|
*/
|
|
|
|
String geheimtext = "";
|
|
|
|
|
|
return geheimtext;
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|