INE2 Von C zu Java Teil 2: Arrays und Strings

Transcription

INE2
Von C zu Java
Teil 2: Arrays und Strings
■ Arrays
■ Referenzdatentypen
■ Strings
1
Arrays
School of Engineering
© G. Burkert, K. Rege, ZHAW
2 von 64
Array
■ Was ist ein Array ?
18
17
21
12
15
8
14
1
33
15
8
12
33
17
18
1
21
14
Index: 0
1
2
3
4
5
6
7
8
Ein Array ist eine Gruppe von Variablen gleichen Typs und gleicher Bedeutung, die
sinnvoll unter demselben Namen angesprochen und intern durchnummeriert
werden
3 von 64
Array
■ Entspricht einer Tabelle mit nur einer Zeile
■ Variablenname bezeichnet die ganze Tabelle
■ Einzelner Eintrag: Element, Komponente
■ Merkmale
■
Alle Daten eines Arrays haben den gleichen Datentyp
■
Einzelnes Element wird durch seinen Index adressiert
4 von 64
Arrays in C (Wh)
■ Wie haben wir Array-Variablen in C definiert?
■ Zum Beispiel:
■
Die sechs Lottozahlen?
■
Die Anzahl Tage jedes Monats im Jahr?
■ Muss man bei der Definition einer Array-Variablen in C die Array-Grösse angeben?
■ Welche zwei Möglichkeiten zum Anlegen und Verwenden von Arrays gibt es in C?
5 von 64
Deklaration eines Arrays in Java
Datentyp[] Arrayname;
■
Datentyp: Datentyp der einzelnen Elemente
■
Das Array existiert nach der Deklaration noch nicht, erst der Variablenname
■
Die Anzahl Elemente im Array sind ebenfalls noch nicht bestimmt
■ Beispiel:
■ int[] fahrtenAmSo;
6 von 64
Arrays / Felder
Array-Datentyp ↔ Element-Datentyp
int[]
Element-Datentyp
Array-Datentyp
Beachte:
Die tatsächliche Länge des Array gehört nicht zum Array-Datentyp
Deklaration,nur die Tatsache, dass es ein Array ist!
7 von 64
Anlegen eines Arrays in Java
Arrayname = new Datentyp [Arraygrösse];
■ Beispiel:
■ fahrtenAmSo = new int[8];
■
Reserviert Speicher für einen Array mit 8 Elementen vom Typ int
8 von 64
Unterschied C – Java
C
int a[5];
// deklariert a und reserviert Platz fuer
// 5 int
Java
int[] a;
a = new int[5];
// deklariert a
// reserviert Platz fuer 5 int
C
int * a;
// oder int a[] in Funktionsdeklaration
a = (int *)malloc(5*sizeof(int));
// reserviert Platz fuer 5 int
9 von 64
Initialisierung
■ Array-Elemente bei der Erzeugung auf die Default-Werte gesetzt
■ Für int-Arrays ist der Default-Wert 0
■ Möglichkeiten zur expliziten Initialisierung:
Jedes Element einzeln:
Besser: Mit for-Schleife:
fahrtenAmSo[0] = 1;
fahrtenAmSo[1] = 1;
...
fahrtenAmSo[7] = 1;
for (int i=0; i<8; i++){
fahrtenAmSo[i] = 1;
}
Direkt bei der Deklaration des Arrays:
int[] fahrtenAmSo = {1,1,1,1,1,1,1,1};
10 von 64
Initialisierung
■ Wenn ein Array direkt initialisiert wird, wird dabei auch die Grösse des Arrays
festgelegt:
double[] messWerte= {1.5, 7.3, 3.6, 9.4};
// Grösse 4
■ Der Initialisierungsausdruck mit geschweiften Klammern ist nur bei der Deklaration
erlaubt
double[] messWerte;
messwerte = {1.5, 7.3, 3.6, 9.4}; // geht nicht !
messWerte = new double[] {1.5, 7.3, 3.6, 9.4}; // ok
11 von 64
Zugriff auf Array-Elemente
Arrayname[index]
■
Greift auf das Element mit dem angegebenen Index zu
■
Das erste Element hat den Index 0 !
■
Ein Array-Element kann verwendet werden wie eine Variable vom entsprechenden Datentyp:
■
Zuweisung, Eingabe, Ausgabe, Argument bei Methodenaufruf, usw.
■ Beispiel:
wert = a[index];
// ein Element lesen
a[index] = 5;
// in ein Element schreiben
12 von 64
Länge eines Arrays
■ Die Länge eines Arrays wird beim Erzeugen festgelegt
■ Sie kann dann nicht mehr verändert werden
■ Sie ist in einer Instanzenvariable des Array-Objekts gespeichert:
arrayname.length
■ Achtung: Das ist keine Methode, also nicht:
arrayname.length()
13 von 64
Final, Umgang mit Array-Elementen
■ Oft werden Arrays mit for-Schleifen bearbeitet
final int ANZAHL = 100;
Tipp:
int[] zweierReihe;
zweierReihe = new int[ANZAHL];
for (int i = 0; i < zweierReihe.length; i++) {
■ Array-Grössen in
Konstanten (mit final)
angeben
zweierReihe[i] = i*2;
■ mit length arbeiren
}
14 von 64
Umgang mit Arrays
■ Arrays sind Java-Objekte
■ Sie werden sie als Referenz (s.u.) übergeben
■ Bei der Parameterdeklaration im Methodenkopf muss die Länge des übergebenen
Arrays nicht spezifiziert werden:
public int summe(int[] arr) {
...
}
15 von 64
Umgang mit Arrays: Beispiel
public int summe(int[] arr) {
int total = 0;
for (int i =0; i < arr.length; i++) {
total = total + arr[i];
}
return total;
}
■ Aufruf:
int[] reihe = {1,2,3,4};
int sum;
sum = summe(reihe);
16 von 64
Übung
■ Schreiben Sie eine Methode, die das grösste Element in einem beliebig langen Array
von ganzen Zahlen zurückgibt
■ Die Methode soll nur den Wert des grössten Elementes zurückgeben
17 von 64
Arrays von Objekten
■ Array von Strings:
String[] arbeitstage = {"Montag", "Dienstag",
"Mittwoch", "Donnerstag", "Freitag"};
int tag = 2;
String tagname;
tagname = arbeitstage[tag];
■ Welchen Index hat der Dienstag?
18 von 64
Programmierfehler
■ Der gewählte Index liegt ausserhalb des erlaubten Bereichs
■
ArrayIndexOutOfBoundsException
■ Ein Array wird verwendet, bevor es erzeugt wird
■
Nullpointer-Exception
In Java ist es nicht möglich ausserhalb der
Array Grenzen zuzugreifen
In Java gibt es das Dangling Pointer Problem nicht
19 von 64
Zweidimensionale Arrays
■ Beispiel: Umsatzzahlen eines Geschäftes mit 3 Filialen für eine Woche
20 von 64
Zweidimensionale Arrays in Java
■ Array, dessen Elemente ebenfalls wieder Arrays sind
■ Deklaration:
Datentyp[][] Arrayname;
■ Erzeugung des Arrays:
Arrayname
= new Datentyp [AnzahlZeilen][AnzahlSpalten];
■ Beispiel:
int[][] umsatz;
umsatz = new int [3][7];
■ Analog sind auch mehrdimensionale Arrays möglich
21 von 64
■ Beispiel: Schachbrett
String[][] schachbrett;
final int GROESSE = 8;
schachbrett = new String[GROESSE][GROESSE];
■ Beispiel: Kinoplätze
boolean[][] kinoplatz;
int anzReihen = 10; anzPlaetzeProReihe = 20;
kinoplatz = new boolean[anzReihen][anzPlaetzeProReihe];
22 von 64
■ Initialisierung
■
Bei der Deklaration:
int [][] tabelle = {{1,0,1},{0,1,0}};
■
Im Programmcode mit for-Schleifen
■ Zugriff auf Array-Elemente
Arrayname[zeilenindex][spaltenindex]
■ Beispiel:
// Element in der 3. Zeile und 4. Spalte des Arrays umsatz:
int ums = umsatz[2][3];
23 von 64
Referenzdatentypen
24 von 64
Referenzdatentyp
■ Array sind Referenzendatentypen
■ Im Gegensatz zu einfachen Datentypen
■ Einfache Datentypen (Wh):
■
Speichern und Verarbeiten einzelne Werte (Zahlen, Buchstaben, logische Werte)
■
Variablenname bezeichnet den Speicherplatz, wo der Wert abgespeichert ist
■
Speicherplatz wird bei der Deklaration der Variablen reserviert
25 von 64
Einfache Datentypen (Wertetypen - Whd)
■ Nur ein Wert
int, double, double, boolean, char, ...
■ Bei Zuweisungen und Methodenaufrufen wird nur Kopie des Wertes übergeben („by
value“)
a = 5;
a
5
b
7 5
b = 7;
b = a;
26 von 64
Referenzdatentyp
■ Speichern und Verarbeiten mehrerer Werte zusammen
■ Die einzelnen Werte vom gleichen oder von unterschiedlichem Datentyp sein
■ Beispiel: Klassen, Arrays (Felder)
■ Bei der Deklaration der Variablen wird nur Platz für die Adresse der eigentlichen Daten
reserviert
■ Daher auch als Referenzdatentypen bezeichnet
27 von 64
Speicherbereich anlegen
■ Der Speicherbereich für die eigentlichen Daten wird durch eine explizite Anweisung
dynamisch im Arbeitsspeicher (Heap) angelegt:
fahrtenAmSo = new int[8];
// Array
■ Der benötigte Speicherplatz wird im Arbeitsspeicher reserviert und die Startadresse
dieses Speicherbereichs in den Speicherplatz für die Referenz abgelegt
■ Vor der Erzeugung des Objekts enthält die Variable noch keine gültige Referenz (null)
28 von 64
Referenzdatentypen
■ Bei Zuweisungen und
Methodenaufrufen wird nur Kopie der
Adresse (Referenz) übergeben
double[] messWerte = { ... };
■ Nach einer Zuweisung existieren 2
Referenzen auf dasselbe Objekt
neueWerte = messWerte;
double[] neueWerte;
messWerte
Ref
neueWerte
null
Ref
29 von 64
Datenübergabe
■ Einfache Datentypen:
Bei der Zuweisung oder der Übergabe von Daten an Methoden wird der Wert der
Variablen übergeben („call by value“)
■ Referenzdatentypen:
Wie bei einfachen Typen, der Wert ist dann aber eine Referenz, d.h. die Adresse der
Daten
■ Nach einer Zuweisung var1 = var2; stellen beide Variablen also Referenzen auf
dieselben Daten dar
■ Bei der Datenübergabe an eine Methode werden ebenfalls Referenzen übergeben:
Methode arbeitet mit den Originaldaten, nicht mit einer Kopie!
30 von 64
Methodenaufruf
public void foo()
int[] a
= {1,2,3,4};
bar(
);
a
System.out.println("Result = "+ a[0]);
}
public void bar(int[] b) {
b[0] = 2;
}
Button
1,2,3,4
1,2,3,4
“A“
31 von 64
Strings
32 von 64
Strings in Java
■ Ein String (eine Zeichenkette) ist eine beliebig lange
Folge von Zeichen (Characters):
■
■
■
Ich bin ein String
2347320984732984
_owjddpoie;:-opüäw%jpowB“+^\/wljd
■ Strings werden in Programmen sehr häufig verwendet
■
■
■
■
Ausgabe von Meldungen
Einlesen von Benutzereingaben
Lesen und Schreiben von Textdateien
Namen von Verzeichnissen, URLs
■ In Java werden Strings als Objekte behandelt
■
■
Ein Objekt enthält einen String beliebiger Länge
Die Zeichen im String werden wie in einem Array indexiert: 0...(Länge – 1)
S
t
r
i
n
g (0)
0
1
2
3
4
5
33 von 64
Deklaration und Initalisierung
Referenzdatentyp: String
■
■
String ist ein Object -> Referenztyp
Strings sind unveränderbar (immutable Object).
■ Deklaration, Initialisierung:
■
String stringName [= "Zeichenfolge"];
■
Zeichenfolgen (String Literals) stehen immer zwischen doppelten Anführungszeichen
■ Frage: Unterschied zw. c = 'a' und s = "a"
?
■ Beispiele:
■
■
String name;
String name = new ("Hugo");
name
name
"Hugo"
"Hugo"
34 von 64
Erzeugung von Strings
■ Erzeugung von Strings
■
■
■
■
■
■
■
name = new ("Hugo");
str = "Hello";
String str = "Hello";
String str = "";
str = name;
// gebräuchliche Schreibweise
// Deklaration und Initialisierung
// Leerer String
Dabei werden nicht einfach die Referenzen kopiert !
Sondern str wird echte Kopie von name zugewiesen
■ Obwohl Strings Objekte sind, verhalten Sie sich wie Wertedatentypen
name
name
"Hugo"
"Hugo"
copy
str = name;
str
str
"Hugo"
"Hugo"
35 von 64
Array of Strings
■ Array of Strings:
■
String[] staedte = new String[2];
staedte[0] = "Winterthur";
staedte[1] = "Zuerich";
■ Erzeugung von Arrays of Strings
■
String [] bergsteiger = {"Messner","Seiler","Sherpa","Yeti"};
36 von 64
Strings als Methodenparameter
■ Bereits bei Zuweisungen von Strings haben wir gesehen, dass sich Strings in wie
primitive Datentypen verhalten:
■
String str1 = "Hello, World";
String str2 = str1;
// Komplette Kopie von str1
■ Dasselbe gilt für die Parameterübergabe:
■
■
■
Der übergebene String verhält sich in der Methode wie eine lokale Kopie
Änderungen innerhalb der Methode haben keinen Einfluss auf den übergebenen String
Sollen die Änderungen zurückgegeben werden g return
■ Beispiel:
private String dupliziere(String str) {
str = str + str;
return str;
}
…
str2 = dupliziere(str1);
37 von 64
Stringgrundoperationen
38 von 64
Konvertierung und Verkettung von Strings
■ Konvertierung einer Zahl in einen String:
■
■
int zahl = 123;
String zahlStr1 = "" + zahl;
String zahlStr2 = Integer.toString(zahl);
// implizit
// explizit
i.M. zahl = Integer.parseInt("123");
■ Zusammenhängen von Strings mit dem + Operator:
■
String str1 = "Hello, ";
String str2 = "World!";
String str3 = str1 + str2;
// Hello, World!
■ Verketten mit Zahlen:
■
String str1 = "Hallo " + 1 + 2; // "Hallo 12"
String str2 = "Hallo " + (1 + 2); // "Hallo 3"
39 von 64
Vergleich von Strings
■ Test auf Gleichheit
■
häufige gemachter Fehler: verwenden von "==":
String s = "abc"; // new String("abc")
String t = "abc"; // new String("abc")
if (s == t) {} : testet auf Gleichheit von Referenz = false
■ equals-Methode von String verwenden
if (s.equals(t)) {} : teste auf Gleichheit von Wert = true
■ equalsignoreCase ignoriert Grossklein-Schreibung
String v = "ABC";
s.equalsignoreCase(v);
ss
"abc"
"abc"
s == t;
tt
s.equals(t);
"abc"
"abc"
40 von 64
Reihenfolge von Strings
■ int compareTo(String str);
■ compareTo Methode bestimmt Reihenfolge
String a = "ameise";
String b = "biene"
int n = a.compareTo(b);
n == 0:
n < 0:
n > 0:
a ist gleich b
a steht vor b "ameise" < "biene"
a steht nach b
■ Aber : "ameise" kommt nach "Biene" (Zeichen-Code Reihenfolge)
■
Lexikographischer Vergleich von str mit dem gegebenen String
■
Strings werden zeichenweise von links nach rechts verglichen
Kein Zeichen kommt vor Sonderzeichen kommt vor Zahlen kommt vor Grossbuchstaben kommt vor
Kleinbuchstaben (entspricht dem jeweiligen Unicode der Zeichen)
■ "a" kommt vor "b"
"a" kommt nach "Z"
■ "abcdzzzz" kommt vor "abce"
"a" kommt vor "ab"
■
■
"a1 " kommt nach "a1"
■
"10" kommt vor "2"
"Anna" kommt
vor
"anna"
41 von 64
Stringmanipulationen
42 von 64
String-Methoden – Manipulationen
■ Wichtig: der aktuelle String wird nicht verändert, sondern Methode gibt einen neuen
String zurück (Strings = immutable Objects)!
■ String replace(char alt, char neu);
■ String replace(string alt, string neu);
■
■
String str1 = "Abrakadabra";
String str2 = str1.replace('a', 'u');
// Abrukudubru
str2 = str2.replace('u', 'a'); // es wird ein neues str2 kreiert
■ String toLowerCase();
■
str2 = str1.toLowerCase();
// abrakadabra
■ String toUpperCase();
■
str2 = str1.toUpperCase();
// ABRAKADABRA
■ String trim();
■
■
Entfernt White Space am Anfang und am Ende
str1 = "
\t
viel leerer Raum
\n\n \t
";
str2 = str1.trim();
// viel leerer Raum
43 von 64
Bei umfangreichen String Manipulationen
■ StringBuffer (oder StringBuilder) für umfangreiche Manipulationen auf Strings
■ Inhaltsveränderung bei StringBuffer möglich!
■ Enthält Methoden, um den eingebetteten String direkt zu manipulieren (z.B. insert,
append)
■ Beispiel umfangreiche Mutationen auf Strings:
■ nicht
String s = "";
for (int i = 0; i < 1000; i++) {
s = s + i;
}
■ sondern
StringBuffer buf = new StringBuffer();
for (int i = 0; i < 1000; i++) {
buf.append(Integer.toString(i)); buf.append(",");
}
String s = buf.toString();
44 von 64
String-Methoden – Untersuchung
■ Beispiel-String für die nachfolgenden Methoden:
String str1 = "eins zwei drei";
01234567… // Position
■ int length();
■
Achtung:
Achtung:bei
beiArrays:
Arrays:
array.length
(ohne
array.length (ohne
Klammern)
Klammern)
// Methode: gibt zurück Anz. Chars im String
int len = str1.length();
// 14
■ char charAt(int index);
■
■
str1 = "eins zwei drei";
char zeichen = str1.charAt(2);
// n
■ int indexOf(String str);
int indexOf(String str, int index);
■
Sucht str im gegebenen String; Beginn der Suche bei index oder von Anfang an
■
Gibt Position des ersten Auftretens zurück oder -1 falls nicht gefunden
int pos = str1.indexOf("dre", 6);
// 10
■
45 von 64
String-Methoden – Untersuchung
■ int lastIndexOf(String str);
int lastIndexOf(String str, int index);
Wie indexOf, sucht aber das letzte Auftreten von str
■ Sucht rückwärts, beginnend bei index oder vom Ende weg
■ int pos = str1.lastIndexOf("e");
■
// 12
■ boolean startsWith(String str);
boolean endsWith(String str);
■
true, wenn der gegebene String mit str beginnt/endet, sonst false
46 von 64
Zerlegung von Strings
47 von 64
Zerlegung von Strings
■ Oftmals ist man nur an einem Teil des Strings interessiert
■ Herauslösen eine Teilstrings aus dem Original
■
■
anhand Positionen : z.B. 4..6
anhand Muster im String: z.B. "IP Adresse= 123.121.12.31"
■ Zerteilen des Strings in Teile, die durch Trennzeichen getrennt sind
■
z.B. "23, 454, 63, 21, 56"
48 von 64
Anhand Positionen
■ String substring(int start, int afterEnd);
■
Gibt Substring zwischen den Zeichen start (inkl. und afterEnd (exkl.) zurück
String str1 = "Biene"
String str2 = str1.substring(1, 4);
// ien
String str3 = str1.substring(1); //bis zum Schluss: iene
■ Das erste Zeichen hat Index 0
■ Das zweite optionale Argument ist der Index des ersten Zeichens nach dem
gewünschten Teilstring
■ Vorsicht
■
beide Werte müssen im gültigen Index Bereich des Strings sein, sonst Laufzeitfehler
B
0
i
1
e
2
n
3
e
4
49 von 64
Zerteilen von Strings: StringTokenizer
■ StringTokenizer (Zer-)teilt einen String in
Substrings (Tokens) auf; die Tokens im String
sind durch Grenzmarken abgetrennt
■ Grenzmarken basieren auf einer Liste der Zeichen
■ Mögliche Anwendung: Untersuchung von Daten
aus einem Text-File, einzelne Datensätze sind z.B. durch Komma, Leerzeichen
Zeilenumbruch oder Tab getrennt
■ Generierung der Tokens:
■
String data = "4, 5, 6 2,8,, 100, 18";
StringTokenizer tokens = new StringTokenizer(data, "\t\n ,");
java.util.*
java.util.*
■
Resultiert in 7 Tokens: 4 5 6 2 8 100 18
■
Man beachte: Folgen von Trennzeichen werden zusammengefasst
String
Stringmit
mitTrennzeichen:
Trennzeichen:tab,
tab,
Leerzeichen;
Leerzeichen;Zeilenumbruch
Zeilenumbruch
oder
oder","","
■ Die Tokens sind im StringTokenizer-Objekt enthalten und können nachfolgend
abgefragt werden
50 von 64
Abfragen der Tokens im StringTokenizer
■ String nextToken();
■
Gibt das vorderste Token zurück und entfernt es von der Liste der Tokens
■ boolean hasMoreTokens();
■
Testet, ob noch Tokens vorhanden sind
■ int countTokens();
■
Gibt die Anzahl noch vorhandener Tokens zurück
■ Beispiel
Tokenizer tokens = new
StringTokenizer(data, "\t\n ,");
while (tokens.hasMoreTokens()) {
System.out.println(tokens.nextToken()));
}
■ Æ in neuen Java-Programmen eher "split" verwenden-> später
51 von 64
Reguläre Ausdrücke
52 von 64
Reguläre Ausdrücke: Regex
■ Zum Suchen von definierten Mustern in Texten d.h. Strings
■
■
■
ein bestimmter String: "ZHAW"
Muster kann "unscharf" definiert sein: z.B. ST15a, ST15b,ST14ac
(Teil-)Muster kann sich wiederholen: 170.12.34.12
■ Die meisten heutigen Programmiersprachen unterstützen die Suche nach Muster in
Form von reguläre Ausdrücke (Regular Expressions oder kurz Regex)
■ Regex ist unabhängig von Java definiert
■ Java Klassenbibliothek definiert im Package java.util.regex
■ die Klassen Pattern und Matcher
53 von 64
Definition des regulären Ausdrucks
■ Zuerst muss der reguläre Ausdruck vorbereitet werden
■ Die Klasse Pattern
■
Pattern pat = Pattern.compile("ZHAW");
■ Das Muster kann im einfachsten Fall ein Textzeichen-String sein
■ Alle Zeichen sind erlaubt ausser: ([{\^-$|]})?*+.
■ Diese müssen mit \ vorangestellt geschrieben werden
■
Vorsicht in Java String Konstante muss "\\" für "\" geschrieben werden
■ Beispiel
■
Pattern pat = Pattern.compile("wie geht's \\?");
54 von 64
Abfrage nach den gefundenen Stellen
■ Ausgabe der gefundenen Stellen
■ Die Klasse Matcher
■
Matcher matcher = pat.matcher("Willkommen an der ZHAW");
■ Suche nächste Textstelle boolean find()
■
true falls gefunden
■
matcher.find();
■ Gebe gefunden Teilstring zurück String group()
■
matcher.group(); ZHAW
■ Start und Endposition innerhalb String int start() und int end()
■
matcher.start(); //18
■ matcher.end(); //22
55 von 64
Vollständiges Beispiel
import java.util.regex.*;
…
Pattern pat = Pattern.compile("ZHAW");
Matcher matcher = pat.matcher("Willkommen an der ZHAW");
while (matcher.find()) {
String group = matcher.group();
int start = matcher.start();
int end = matcher.end();
// do something
}
56 von 64
Platzhalter
■ Oftmals wird nach unscharfen Muster gesucht, z.B. alle ET Klassen
■ Es sind Platzhalter Zeichen erlaubt, die Zeichenmengen matchen
■
z.B. "." für beliebiges Zeichen "\d" für Zahl, ^\d für keine Zahl
Platzhalter Beispiel
.
a.b
\d
\d\d
\D
\D
^
^\d
\s
\s
\S
\S
Bedeutung
Ein beliebiges Zeichen
Digit[0-9]
kein Digit
Negation
Leerzeichen (Blank,etc)
kein Leerzeichen
Menge der gültigen Literale
aab, acb, aZb, a[b, ...
78, 10
a, b , c
a, b , c
blank, tab, cr,
■ Aufgabe: Geben Sie das Suchmuster für beliebige ST Klassen an: ST15a, ST15b,
ST14a
ET\d\d.
57 von 64
Eigene Zeichenmengen
■ Statt vordefinierte Zeichenmengen zu verwenden, können auch eigene definiert werden
■ diese werden in "[" "]" geklammert
■ Aufzählung der Zeichen in der Zeichenmenge
■
■
ein Zeichen aus der Menge
z.B. "a", "b" oder "c" : [abc]
■ Bereiche
■
z.B. alle Kleinbuchstaben [a-z] alle Buchstaben [a-zA-Z]
■ Negation: Alle Zeichen ausser
■
z.B. [^a]
■ Aufgabe: Geben Sie das Suchmuster für beliebige ET Klassen an; es gäbe aber nur "a"
bis "d"
ET\d\d[a-d]
58 von 64
Optional, Alternative und Wiederholung
■ Optionale Teile: ?
■
wenn einzelner Buchstaben optional, z.B. ZHA?W -> ZHW oder ZHAW
■ Alternative |
■
■
wenn ein A oder B -> ZH(A|B)W -> ZHAW oder ZHBW
"natürliche" Verwendung von Klammern
Wiederholungen
Auch
Auch00mal
mal
erlaubt
erlaubt
■ Beliebig oft *
■
eine Folge von Ziffern \d* -> _, 2,23,323,423,..
■ Mindestens einmal +
■
eine Folge von Ziffern aber mindest eine \d+ -> 3,34,234,…
■ Bestimmte Anzahl mal {n}
■
eine Folge von drei Ziffern \d{3} -> 341,241,123 ..
■ Mindestens, maximal Anzahl mal {n,m}
■
eine Folge von 1 bis 3 Ziffern \d{1,3} -> 1, 23, 124, ...
59 von 64
Zusammenfassung Metasymbole
■ (Meta-)Sprache zur Beschreibung der Bildungsregeln von Sätzen
■ Metasymbole: *,+,?,|,(),.[]
Metasymbol
*
+
?
|
()
.
[]
[-]
\d
\D
^
\s
\S
Beispiel
ax*b
ax+b
ax?b
a|b
x(a|b)x
a.b
[abc]x
[a-h]
\d\d
\D
^\d
\s
\S
Bedeutung
0 oder mehrere x
1 oder mehrere x
x optional
a oder b
Gruppierung
Ein beliebiges Zeichen
1 Zeichen aus einer Menge
Zeichenbereich
Digit[0-9]
kein Digit
Negation
Leerzeichen (Blank,etc)
kein Leerzeichen
Menge der gültigen Literale
ab, axb, axxb, axxxb, ...
axb, axxb, axxxb, ...
ab, axb
a, b
xax, xbx
aab, acb, aZb, a[b, ...
ax, bx, cx
a,b,c, ..., h
78, 10
a, b , c
a, b , c
blank, tab, cr,
60 von 64
Weitere String-Methoden für Regex
■ Prüfe of String einem Regex Muster entspricht
■ boolean matches(String regexp);
■
String text = "Hallo Welt";
boolean passt;
passt = text.matches("H.*W.*");
passt = text.matches("H..o Wel?t");
passt = text.matches("H[alo]* W[elt]+");
passt = text.matches("Hal+o Welt.+");
//
//
//
//
true
false
true
false
■ Aufgabe: Regex zum Prüfen ob ein String eine Int Zahl enthält
-?\d+
■ Aufgabe: Regex zum Prüfen ob ein String eine IP Adresse enthält
\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}
61 von 64
… Weitere String-Methoden für Regex
■ String replaceAll(String regexp, String replaceStr);
■ String replaceFirst(String regexp, String replaceStr);
■
■
Ersetzt im gegebenen String alle (bzw. den Ersten bei replaceFirst) Substrings, die regexp
entsprechen, mit replaceStr
String new = text.replaceAll("l+", "LL");
// HaLLo WeLLt
■ String[] split(String regexp);
■
Teilt den gegebenen String in mehrere Strings, regexp ist die Grenzmarke
■
Das Resultat ist ein Array mit Teilstrings
String data = "4, 5, 6 2,8,, 100, 18"
String[] teile = data.split("[ ,]+");
// 4 5 6 2 8 100 18
// teile[0] = "4", teile[1] = "5", ….
■
■
// Menge der Zeichen " " und","
62 von 64
Reguläre Ausdrücke – Übung
63 von 64
Noch Fragen?
64 von 64

INE2 Von C zu Java Teil 2: Arrays und Strings

Transcription

Documents pareils

Übung 7

Portable LED Flasher

1 Fa - Technische Universität München

Merkblatt Variablen und ArrayList

häufig gestellte fragen zu den goethe

Visual Basic Entwicklungs

Programmieren II, SS12 Tutorium: Übungen Aufgabe 1

Software Engineering 1