From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- .../hjp5/html/k100072.html | 793 +++++++++++++++++++++ 1 file changed, 793 insertions(+) create mode 100644 Master/Reference Architectures and Patterns/hjp5/html/k100072.html (limited to 'Master/Reference Architectures and Patterns/hjp5/html/k100072.html') diff --git a/Master/Reference Architectures and Patterns/hjp5/html/k100072.html b/Master/Reference Architectures and Patterns/hjp5/html/k100072.html new file mode 100644 index 0000000..1a74775 --- /dev/null +++ b/Master/Reference Architectures and Patterns/hjp5/html/k100072.html @@ -0,0 +1,793 @@ + + + +Handbuch der Java-Programmierung, 5. Auflage + + + + + + + + + +
 Titel  + Inhalt  + Suchen  + Index  + DOC  +Handbuch der Java-Programmierung, 5. Auflage +
 <<  +  <   +  >   + >>  + API  +Kapitel 11 - Strings +
+
+ + + + +

11.2 Methoden der Klasse String

+
+ +
+ +

+Die Klasse String +definiert eine Vielzahl von Methoden zur Manipulation und zur Bestimmung +der Eigenschaften von Zeichenketten. Da Strings und die auf ihnen +definierten Operationen bei der Anwendung einer Programmiersprache +ein wichtiges und für die Effizienz der Programmentwicklung kritisches +Merkmal sind, sollen hier die wichtigsten String-Operationen vorgestellt +werden. Weitere Methoden dieser Klasse können den Referenzhandbüchern +der Java-Klassenbibliothek oder der Online-Hilfe entnommen werden. + + + + +

11.2.1 Konstruktoren

+ +

+Die Klasse String +bietet eine Reihe von Möglichkeiten, neue Instanzen zu erzeugen. +Neben der bereits in Kapitel 4 +erläuterten Initialisierung mit Hilfe von Literalen besitzt die +Klasse eine Reihe von Konstruktoren, die dazu verwendet werden können, +String-Objekte +explizit zu erzeugen. +

+ + + + + +
+ +
+String()
+
+ +		 +java.lang.String
+ +

+Erzeugt ein leeres String-Objekt. +

+ + + + + +
+ +
+String(String value)
+
+ +		 +java.lang.String
+ +

+Erzeugt einen neuen String durch Duplizierung eines bereits vorhandenen. +

+ + + + + +
+ +
+String(char[] value)
+
+ +		 +java.lang.String
+ +

+Erzeugt einen neuen String aus einem vorhandenen Zeichen-Array. Dabei +werden alle Elemente des Arrays in den String übernommen. +

+ + + + + + + + + +
+ +

+Nachdem ein String +erzeugt wurde, kann er wie jedes andere Objekt verwendet werden. Insbesondere +erfolgt damit im Gegensatz zu C oder C++ das Speichermanagement vollautomatisch, +ohne dass sich der Programmierer darum kümmern muss.

 + + + + +
 Hinweis 
+
+ + + + +

11.2.2 Zeichenextraktion

+

+ + + + + +
+ +
+char charAt(int index)
+  throws StringIndexOutOfBoundsException
+
+ +		 +java.lang.String
+ +

+Liefert das Zeichen an Position index. +Dabei hat das erste Element eines Strings den Index 0 und das letzte +den Index length()-1. Falls +der String kürzer als index + 1 +Zeichen ist, wird eine Ausnahme des Typs StringIndexOutOfBoundsException +erzeugt. +

+ + + + + +
+ +
+String substring(int begin, int end)
+
+ +		 +java.lang.String
+ +

+ Liefert den Teilstring, der an Position begin +beginnt und an Position end +endet. Wie bei allen Zugriffen über einen numerischen Index beginnt +auch hier die Zählung bei 0. +

+ + + + + + + + + +
+ +

+Ungewöhnlich bei der Verwendung dieser Methode ist die Tatsache, +dass der Parameter end auf das +erste Zeichen hinter den zu extrahierenden Teilstring verweist +(siehe Abbildung 11.1). +Der Rückgabewert ist also die Zeichenkette, die von Indexposition +begin bis Indexposition end +- 1 reicht.

 + + + + +
 Hinweis 
+
+

+ + +

+ +

+Abbildung 11.1: Ein Aufruf von substring(begin, end)

+ +

+Es gibt noch eine zweite Variante der Methode substring, +die mit nur einem einzigen Parameter aufgerufen wird. Sie liefert +den Teilstring von der angegebenen Position bis zum Ende des Strings. +

+ + + + + +
+ +
+String trim()
+
+ +		 +java.lang.String
+ +

+Die Methode liefert den String, der entsteht, wenn auf beiden Seiten +der Zeichenkette jeweils alle zusammenhängenden Leerzeichen entfernt +werden. Dabei werden alle Zeichen, die einen Code kleiner gleich 32 +haben, als Leerzeichen angesehen. Leider gibt es keine separaten Methoden +für das rechts- oder linksbündige Entfernen von Leerzeichen, +trim +entfernt immer die Leerzeichen auf beiden Seiten. Da die Klasse String +als final +deklariert wurde, gibt es auch keine Möglichkeit, entsprechende +Methoden nachzurüsten. + + + + +

11.2.3 Die Länge der Zeichenkette +

+

+ + + + + +
+ +
+int length()
+
+ +		 +java.lang.String
+ +

+Liefert die aktuelle Länge des String-Objekts. +Ist der Rückgabewert 0, so bedeutet dies, dass der String leer +ist. Wird ein Wert n größer 0 zurückgegeben, +so enthält der String n Zeichen, die an den Indexpositionen +0 bis n - 1 liegen. + +

+Das folgende Beispiel zeigt die Verwendung der Methoden substring +und length +und der String-Verkettung + auf (letztere wird in Abschnitt 11.3.2 +noch einmal genauer behandelt). + + +

+ + + + + +
+ +
+001 /* Listing1101.java */
+002 
+003 public class Listing1101
+004 {
+005   public static void main(String[] args)
+006   {
+007     String s1;
+008     s1 =  "Auf der Mauer";
+009     s1 += ", auf der Lauer";
+010     s1 += ", sitzt \'ne kleine Wanze";
+011     System.out.println(s1);
+012 
+013     for (int i = 1; i <= 5; ++i) {
+014       s1 = s1.substring(0,s1.length()-1);
+015       System.out.println(s1);
+016     }
+017   }
+018 }
+ +		 +Listing1101.java
+ +Listing 11.1: String-Verkettung und die Methode substring

+ +

+Die Ausgabe des Programms ist: + +

+Auf der Mauer, auf der Lauer, sitzt 'ne kleine Wanze
+Auf der Mauer, auf der Lauer, sitzt 'ne kleine Wanz
+Auf der Mauer, auf der Lauer, sitzt 'ne kleine Wan
+Auf der Mauer, auf der Lauer, sitzt 'ne kleine Wa
+Auf der Mauer, auf der Lauer, sitzt 'ne kleine W
+Auf der Mauer, auf der Lauer, sitzt 'ne kleine
+
+ + + + + +

11.2.4 Vergleichen von Zeichenketten

+

+ + + + + +
+ +
+boolean equals(Object anObject)
+boolean equalsIgnoreCase(String s)
+
+boolean startsWith(String s)
+boolean endsWith(String s)
+
+int compareTo(String s)
+
+boolean regionMatches(
+   int toffset,
+   String other,
+   int ooffset,
+   int len
+)
+
+ +		 +java.lang.String
+ +

+equals +liefert true, +wenn das aktuelle String-Objekt und anObject +gleich sind. Analog zu der gleichnamigen Methode der Klasse Object +überprüft equals +also nicht, ob beide Strings dasselbe Objekt referenzieren, sondern +testet auf inhaltliche Gleichheit. Interessant an equals +ist die Tatsache, dass als Parameter ein Objekt der Klasse Object +erwartet wird. equals +kann einen String also nicht nur mit einem anderen String vergleichen, +sondern mit der String-Darstellung eines beliebigen Objekts. + +

+Neben equals +gibt es noch eine ähnliche Methode, equalsIgnoreCase, +die eventuell vorhandene Unterschiede in der Groß-/Kleinschreibung +beider Zeichenketten ignoriert. + +

+startsWith +testet, ob das String-Objekt mit der Zeichenkette s +beginnt. Ist das der Fall, so gibt die Methode true +zurück, andernfalls false. +endsWith +überprüft dagegen, ob das String-Objekt mit der Zeichenkette +s endet. Ist das der Fall, gibt +die Methode ebenfalls true +zurück, andernfalls false. + +

+Die wichtige Methode compareTo +führt einen lexikalischen Vergleich beider Strings durch. +Bei einem lexikalischen Vergleich werden die Zeichen paarweise von +links nach rechts verglichen. Tritt ein Unterschied auf oder ist einer +der Strings beendet, wird das Ergebnis ermittelt. Ist das aktuelle +String-Objekt dabei kleiner als s, +wird ein negativer Wert zurückgegeben. Ist es größer, +wird ein positiver Wert zurückgegeben. Bei Gleichheit liefert +die Methode den Rückgabewert 0. + +

+regionMatches +vergleicht zwei gleich lange String-Regionen, die in zwei unterschiedlichen +Strings an zwei unterschiedlichen Positionen liegen können. Die +Region im ersten String beginnt dabei an der Position toffset, +die im zweiten String other +an der Position ooffset. Verglichen +werden len Zeichen. Das Ergebnis +ist true, +wenn beide Teilstrings identisch sind, andernfalls ist es false. +Die Methode steht auch in einer Variante zur Verfügung, bei der +Groß- und Kleinschreibung ignoriert werden. In diesem Fall wird +als zusätzlicher Parameter an erster Stelle ein boolescher Wert +ignoreCase übergeben. + +

+Die Anwendung von regionMatches +soll an folgendem Beispiel erläutert werden. Der erste Vergleich +liefert true +(siehe Abbildung 11.2), +der zweite false: + + +

+ + + + + +
+ +
+001 /* Listing1102.java */
+002 
+003 public class Listing1102
+004 {
+005   public static void main(String[] args)
+006   {
+007     System.out.println(
+008       "Grüße aus Hamburg".regionMatches(
+009         8,
+010         "Greetings from Australia",
+011         8,
+012         2
+013       )
+014     );
+015     System.out.println(
+016       "Grüße aus Hamburg".regionMatches(
+017         6,
+018         "Greetings from Australia",
+019         15,
+020         3
+021       )
+022     );
+023   }
+024 }
+ +		 +Listing1102.java
+ +Listing 11.2: Die Methode regionMatches der Klasse String

+

+ + +

+ +

+Abbildung 11.2: Der Aufruf von regionMatches

+ +

+Eine weitere Möglichkeit Zeichenketten zu vergleichen bieten +die Regulären Ausdrücke, die in Abschnitt 17.1 +beschrieben werden. + + + + +

11.2.5 Suchen in Zeichenketten

+

+ + + + + +
+ +
+int indexOf(String s)
+int indexOf(String s, int fromIndex)
+int lastIndexOf(String s)
+
+ +		 +java.lang.String
+ +

+Die Methode indexOf +sucht das erste Vorkommen der Zeichenkette s +innerhalb des String-Objekts. +Wird s gefunden, liefert die +Methode den Index des ersten übereinstimmenden Zeichens zurück, +andernfalls wird -1 zurückgegeben. Die Methode gibt es auch in +einer Version, die einen Parameter vom Typ char +akzeptiert. In diesem Fall sucht sie nach dem ersten Auftreten des +angegebenen Zeichens. + +

+Die zweite Variante von indexOf +arbeitet wie die erste, beginnt mit der Suche aber erst ab Position +fromIndex. Wird s +beginnend ab dieser Position gefunden, liefert die Methode den Index +des ersten übereinstimmenden Zeichens, andernfalls -1. Auch diese +Methode gibt es in einer Variante, die anstelle eines String-Parameters +ein Argument des Typs char +erwartet. Ihr Verhalten ist analog zur vorherigen. + +

+Die Methode lastIndexOf +sucht nach dem letzten Vorkommen des Teilstrings s +im aktuellen String-Objekt. +Wird s gefunden, liefert die +Methode den Index des ersten übereinstimmenden Zeichens, andernfalls +-1. Wie die beiden vorherigen Methoden gibt es auch lastIndexOf +wahlweise mit einem Parameter vom Typ char +und mit einem zweiten Parameter, der die Startposition der Suche bestimmt. + + + + +

11.2.6 Ersetzen von Zeichenketten

+

+ + + + + +
+ +
+String toLowerCase()
+String toUpperCase()
+
+String replace(CharSequence oldString, CharSequence newString)
+
+ +		 +java.lang.String
+ +

+Die Methode toLowerCase +liefert den String zurück, der entsteht, wenn alle Zeichen des +Argumentstrings in Kleinbuchstaben umgewandelt werden. Besitzt der +String keine umwandelbaren Zeichen, wird der Original-String zurückgegeben. +toUpperCase +arbeitet ganz ähnlich, liefert aber den String, der entsteht, +wenn alle Zeichen in Großbuchstaben umgewandelt werden. Besitzt +der String keine umwandelbaren Zeichen, wird der Original-String zurückgegeben. + +

+Mit Hilfe von replace +werden alle Vorkommen der Zeichenkette oldString +durch newString ersetzt. Dafür +wird die Zeichenkette von vorn nach hinten durchlaufen, so dass ein +Ersetzen von aa durch ab +auf dem Ausgangswort aaa zum +Resultat aba führt. + +

+Neben der Methode replace enthält +das JDK noch eine zweite namens replaceAll. +Diese akzeptiert statt der Originalzeichenkette auch einen Regulären +Ausdruck, dessen vorkommen dann mit der zweiten Zeichenkette ersetzt +werden. Reguläre Ausdrücke und ihre Verwendung finden Sie +in Abschnitt 17.1. +

+ + + + + + + + + + + +
+ +

+Bei CharSequence im obrigen +Listing handelt es sich um ein Interface die in Abschnitt 9.1 +beschrieben werden. Dieses Interface wird von allen zeichenorientierten +Klassen der Java Standardbibliothek beschrieben und am Ende dieses +Kapitels vorgestellt.

 + + + + +
 Tipp 
+
+ + + + +

11.2.7 Ersetzen von Zeichenketten

+ +

+Mit Hilfe der Methode split +können Zeichenketten in mehrere Teile zerlegt werden. Das folgende +Programm verdeutlicht, dies anhand einer einfachen Zeichenkette: + + +

+ + + + + +
+ +
+001 /* Listing1103.java */
+002 
+003 public class Listing1103
+004 {
+005   public static void main(String[] args)
+006   {
+007     String satz = "Dies ist nur ein Test";
+008     String[] result = satz.split("\\s");
+009     for (int x=0; x<result.length; x++) {
+010       System.out.println(result[x]);
+011     }
+012   }
+013 }
+ +		 +Listing1103.java
+ +Listing 11.3: Zerlegen von Zeichenketten

+ +

+Die Programmausgabe ist: + +

+Dies
+ist
+nur
+ein
+Test
+
+ + +

+Der Parameter, den die Methode split +dabei erwartet ist ein Regulärer Ausdruck, welcher die zu verwendenden +Trennzeichen beschreibt. '\s' +ist hierbei eine Kurzform für alle Arten von »Leerzeichen«. +Reguläre Ausdrücke und ihre Verwendung werden in Abschnitt 17.1 +vorgestellt. +

+ + + + + + + + + + + +
+ +

+Die Methode split wurde mit +dem JDK 5 in Java eingeführt. In den früheren Versionen +bediente man sich hierfür der Hilfsklasse StringTokenizer. +Um die Abwärtskompatibilität von Java-Programmen zu gewährleisten +ist diese natürlich auch weiterhin Bestandteil der aktuellen +JDKs.

 + + + + +
 JDK1.1-6.0 
+
+ + + + +

11.2.8 Konvertierungsfunktionen

+ +

+Da es oftmals nötig ist, primitive Datentypen in Zeichenketten +umzuwandeln, bietet Java eine ganze Reihe von Methoden, die zu diesem +Zweck entwickelt wurden. Allen Methoden ist der Name valueOf +und die Tatsache, dass sie exakt einen Parameter erwarten, gemein. + +

+Alle valueOf-Methoden +sind als Klassenmethoden implementiert, d.h. sie können auch +ohne ein String-Objekt +aufgerufen werden. Dies macht Sinn, denn sie werden ja in aller Regel +erst dazu verwendet, Strings zu erzeugen. Ein Aufruf von valueOf +wandelt ein primitives Objekt mit Hilfe der Methode toString, +die von der zugehörigen Wrapper-Klasse zur Verfügung gestellt +wird, in eine Zeichenkette um. Die wichtigsten valueOf-Methoden +sind: +

+ + + + + +
+ +
+static String valueOf(boolean b)
+static String valueOf(char c)
+static String valueOf(char[] c)
+static String valueOf(double d)
+static String valueOf(float f)
+static String valueOf(int i)
+static String valueOf(long l)
+static String valueOf(Object obj)
+
+ +		 +java.lang.String
+

+ + + + + + + + + + + +
+ +

+Die meisten Java-Wrapperklassen für Basistypen im Paket java.lang +enthalten übrigens das Pendant zu valueOf. +Diese erwarten einen String +und geben den jeweiligen Basistyp zurück. Mehr zum Thema Pakete +in Java finden Sie in Abschnitt 13.1.5.

 + + + + +
 Tipp 
+
+

+ + + +
 Titel  + Inhalt  + Suchen  + Index  + DOC  +Handbuch der Java-Programmierung, 5. Auflage, Addison +Wesley, Version 5.0.1 +
 <<  +  <   +  >   + >>  + API  +© 1998, 2007 Guido Krüger & Thomas +Stark, http://www.javabuch.de +
+ + + -- cgit v1.2.3