Was ist der Output des folgenden Codes?
Pattern p = Pattern.compile(“\\s”);
Matcher m = p.matcher(“Dies ist eine Übung”);
while (m.find())
System.out.println(m.start());
| Antwort/ answer | |
|---|---|
Jun 28
Jun 07
Einen völlig anderen Suchmechanismus bietet die Klasse Scanner:
String FindeMich = “a”; // Definition des zu suchenden Zeichens
System.out.println(“gesucht wird nach “+FindeMich);
System.out.print(“Zu bearbeitender String: “); // Warten auf Benutzereingabe des zu durchsuchenden Strings
System.out.flush();
try {
Scanner s = new Scanner (System.in); // Anlage eines neuen Objektes vom Typ Scanner, der gleichzeitig die Eingabe des Benutzers einliest
String Zeichen;
do{
Zeichen = s.findInLine(FindeMich); // Speicherung des gefundenen Substrings in der Variable “Zeichen”
System.out.println(“gefunden: “+Zeichen); //Ausgabe
}while (Zeichen != null); // Ausführung der Schleife, bis kein weiterer Substring gefunden wurde
} catch (Exception e) { e.printStackTrace();}
Bei einer Benutzereingabe Afganistan erhalten wir folgenden Output:
gesucht wird nach a
Zu bearbeitender String: Afganistan
gefunden: a
gefunden: a
gefunden: null
Jun 05
die Methoden find(), group() und start() habe ich schon angewandt, trotzdem hier nochmal die Übersicht, welche Funktion welches Ergebnis erzielt:
find()
gibt “true” zurück, wenn der gesuchte String gefunden wurde und merkt sich die start-position des matches, um ab diesem Punkt die Suche fortzusetzen
start()
gibt die Position zurück, ab der der gesuchte String gefunden wurde. Wie bei Arrays wird hier die 1.Stelle mit 0 ausgegeben.
group()
gibt den gefundenen String zurück
Jun 03
Natürlich kann auch mittels veränderbaren Variablen gesucht und gefunden werden:
String a = “\\d”;
String b = “c2ckcckcx9ckckx7c”;
Pattern p = Pattern.compile(a);
Matcher m = p.matcher(b);
boolean c = false;
while (c=m.find())
System.out.println(m.start() +” “+m.group());
Es werden also im String b alle Dezimalzahlen gesucht. Folglich ist die Ausgabe:
1 2
9 9
15 7
Mai 31
Heute noch das letzte Beispiel zu (nicht) gierigen Operatoren:
Pattern p = Pattern.compile(“ckc.+”);
Matcher m = p.matcher(“c2ckcckcx9ckckx7c”);
boolean b = false;
while (b=m.find())
System.out.println(m.start() +” “+m.group());
‘.’ dient immer noch als Ersatz für ein Zeichen; ‘+’wird nach einer oder unendlich vielen Zeichenketten gesucht.
Folglich ist die Ausgabe:
2 ckcckcx9ckckx7c
Erst einmal kein Unterschied zu ‘:*?’. Schauen wir uns die Abänderung zum nicht-gierigen Operator mal an:
Pattern p = Pattern.compile(“ckc.+?“);
Hier ist die Ausgabe:
2 ckcc
10 ckck
Zum Vergleich, bei Einsatz von ‘*’ (kein oder beliebig oftes Vorkommen) war die nicht-gierige Ausgabe:
2 ckc
5 ckc
10 ckc
Mai 29
Nachdem wir uns beim letzten Mal auf *? fokusiert haben, möchte ich noch ?? und +? vorstellen.
Beginnen wir heute mit ??:
Pattern p = Pattern.compile(“ckc.?”);
Matcher m = p.matcher(“c2ckcckcx9ckckx7c”);
boolean b = false;
while (b=m.find())
System.out.println(m.start() +” “+m.group());
‘.’ dient wieder als Platzhalter für 1 Zeichen, ‘?’ bedeutet, das diese Zeichenfolge 0 oder einmal vorhanden sein muss.
Folglich ist die Ausgabe hier:
2 ckcc
10 ckck
Nach Abänderung auf nicht-Gierigkeit:
Pattern p = Pattern.compile(“ckc.??“);
ist die Ausgabe:
2 ckc
5 ckc
10 ckc
Mai 27
Heute wollen wir uns mal (nicht) gierige Operatoren anschauen und lernen, diese zu unterscheiden:
Pattern p = Pattern.compile(“ckc.*”);
Matcher m = p.matcher(“c2ckcckcx9ckckx7c”);
boolean b = false;
while (b=m.find())
System.out.println(m.start() +” “+m.group());
‘.’ dient ja als Ersatz für jeden möglichen anderen Charakter, mit ‘*’ wird nach einem oder unendliche vielen dieser Zeichenkette (ckc + weiterer Charakter) gesucht.
Folglich wäre die Ausgabe:
2 ckcckcx9ckckx7c
Es wird also in diesem Falle alles ausgegeben, der Operator ist gierig. Quasi ist hier der Auftrag: Decke die längstmögliche Zeichenkette ab. Um diesen nicht gierig zu machen, wird noch ein ‘?’ hinzugefügt:
Pattern p = Pattern.compile(“ckc.*?“);
Nun ist die Ausgabe:
2 ckc
5 ckc
10 ckc
Mai 25
‘.’ dient als Ersatz für jeden möglichen anderen Charakter.
Pattern p = Pattern.compile(“1.3″);
Matcher m = p.matcher(“123 13 12 1c3″);
boolean b = false;
while (b=m.find())
System.out.println(m.start() +” “+m.group());
Somit ist die Ausgabe hier:
0 123
10 1c3
Mai 23
Schauen wir uns mal folgende Suche genauer an:
Pattern p = Pattern.compile(“\\w\\w\\w([-\\s])\\w\\w”);
Matcher m = p.matcher(“ccc-ccccc”);
boolean b = false;
while (b=m.find())
System.out.println(m.start() +” “+m.group());
Hier wird nach einem String gesucht, der 3 Zeichen und dann genau eine Leerstelle oder ein ‘-’ und danach wieder 2 Zeichen enthält.
Folglich ist die Ausgabe: 0 ccc-cc
Sollten mehr als 1 Zwischenzeichen erlaubt sein, müsste Pattern auf
Pattern p = Pattern.compile(“\\w\\w\\w([-\\s])*\\w\\w”);
abgeändert werden.
Mai 21
Für den Fall, das alle Zeichen, ab einem bestimmten Zeichen ausgegeben werden sollen, gibt es natürlich auch eine Lösung:
Pattern p = Pattern.compile(“c([^,])*”);
Matcher m = p.matcher(“cccxcc”);
boolean b = false;
while (b=m.find())
System.out.println(m.start() +” “+m.group());
Die Ausgabe ist demnach:
0 cccxcc
