INE2 Von C zu Java Teil 2: Arrays und Strings Arrays Referenzdatentypen Strings 1
Arrays 2 von 64
Array Was ist ein Array? 15 12 17 18 21 8 33 1 14 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; // deklariert a a = new int[5]; // 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: fahrtenamso[0] = 1; fahrtenamso[1] = 1;... fahrtenamso[7] = 1; Besser: Mit for-schleife: 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; int[] zweierreihe; zweierreihe = new int[anzahl]; for (int i = 0; i < zweierreihe.length; i++) { zweierreihe[i] = i*2; } Tipp: Array-Grössen in Konstanten (mit final) angeben 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
Zweidimensionale Arrays in Java 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
Zweidimensionale Arrays in Java 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; b = 7; b = a; a 5 b 7 5 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 Nach einer Zuweisung existieren 2 Referenzen auf dasselbe Objekt double[] messwerte = {... }; double[] neuewerte; neuewerte = messwerte; messwerte neuewerte Ref 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 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"; // gebräuchliche Schreibweise String str = "Hello"; // Deklaration und Initialisierung String str = ""; // Leerer String str = name; 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" str = name; copy 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; // implizit String zahlstr2 = Integer.toString(zahl); // 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); s s s == t; "abc" "abc" s.equals(t); t 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" "Anna" kommt vor "anna" "10" kommt vor "2" 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 Achtung: Achtung: bei bei Arrays: Arrays: array.length array.length (ohne (ohne Klammern) Klammern) int length(); int len = str1.length(); // 14 // Methode: gibt zurück Anz. Chars im String 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 i e n e 0 1 2 3 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 Die Tokens sind im StringTokenizer-Objekt enthalten und können nachfolgend abgefragt werden String String mit mit Trennzeichen: Trennzeichen: tab, tab, Leerzeichen; Leerzeichen; Zeilenumbruch Zeilenumbruch oder oder "," "," 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 Bedeutung Menge der gültigen Literale. a.b Ein beliebiges Zeichen aab, acb, azb, a[b,... \d \d\d Digit[0-9] 78, 10 \D \D kein Digit a, b, c ^ ^\d Negation a, b, c \s \s Leerzeichen (Blank,etc) blank, tab, cr, \S \S kein Leerzeichen 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 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} Auch Auch 0 0 mal mal erlaubt erlaubt 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 Beispiel Bedeutung Menge der gültigen Literale * ax*b 0 oder mehrere x ab, axb, axxb, axxxb,... + ax+b 1 oder mehrere x axb, axxb, axxxb,...? ax?b x optional ab, axb a b a oder b a, b () x(a b)x Gruppierung xax, xbx. a.b Ein beliebiges Zeichen aab, acb, azb, a[b,... [] [abc]x 1 Zeichen aus einer Menge ax, bx, cx [-] [a-h] Zeichenbereich a,b,c,..., h \d \d\d Digit[0-9] 78, 10 \D \D kein Digit a, b, c ^ ^\d Negation a, b, c \s \s Leerzeichen (Blank,etc) blank, tab, cr, \S \S kein Leerzeichen 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("[,]+"); // Menge der Zeichen " " und"," // 4 5 6 2 8 100 18 // teile[0] = "4", teile[1] = "5",. 62 von 64
Reguläre Ausdrücke Übung 63 von 64
Noch Fragen? 64 von 64