300 lines
10 KiB
Java
300 lines
10 KiB
Java
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 ;
|
|
|
|
for(int i = 0;i< text.length() ; i++)
|
|
{
|
|
if(text.charAt(i)== z) //if z einmal vorkommt
|
|
{
|
|
anzahl = anzahl+1;
|
|
}
|
|
}
|
|
|
|
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 = "";
|
|
for(int i=text.length()-1;i>=0;i--)
|
|
{
|
|
ergebnis = ergebnis + text.charAt(i);
|
|
}
|
|
|
|
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.).
|
|
*/
|
|
for(int i = text.length()-1;i>0;i++)
|
|
{
|
|
if(text.charAt(i) == text.charAt(text.length - 1 - i){
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|