Strings

Motivation

• Die meisten Programme verarbeiten Zeichenketten
• Texte für Anzeigen am Bildschirm
• Texte von Eingaben
• Daten wie Namen, Adressen, etc.
• Datentyp für Zeichenketten ist daher wichtig

Strings werden in der Java-Programmierung benötigt, um Texte und Zeichenketten darzustellen und zu verarbeiten, z. B. Namen, Adressen, Benutzereingaben, Fehlermeldungen oder Inhalte aus Dateien. Ohne den Datentyp String müsste man Texte umständlich als Arrays von Zeichen (char[]) verwalten, was die Handhabung deutlich erschwert.

String

Zeichenketten (strings) werden in Java mit dem Datentyp String verwaltet

• Referenzdatentyp (vgl. Arrays)
• speichert eine beliebige Anzahl von Zeichen (0, 1, …)
• basiert intern auf einem Array von Zeichen (char[])
• kann beliebige Unicode-Zeichen enthalten
• Erzeugung über String-Literal oder new String()
• nach der Erzeugung kann der String nicht mehr verändert werden

Zeichenketten, auch Strings genannt, werden in Java mit dem Datentyp String verwaltet. Dabei handelt es sich um einen Referenzdatentyp, ähnlich wie bei Arrays. Ein String kann eine beliebige Anzahl von Zeichen enthalten, von einer leeren Zeichenkette (0 Zeichen) bis hin zu sehr langen Texten. Intern basiert ein String auf einem Array von Zeichen (char[]), was bedeutet, dass jedes einzelne Zeichen im String als char gespeichert wird.

Strings in Java können beliebige Unicode-Zeichen enthalten, sodass auch internationale Schriftzeichen, Sonderzeichen oder Emojis problemlos dargestellt und verarbeitet werden können. Ein String kann entweder durch ein sogenanntes String-Literal wie "Hallo" oder durch Verwendung des Konstruktors new String("Hallo") erzeugt werden.

Wichtig ist, dass Strings in Java unveränderlich (immutable) sind. Das bedeutet: Nach der Erzeugung kann der Inhalt eines Strings nicht mehr verändert werden. Wenn zum Beispiel ein neuer Text an einen bestehenden String angehängt wird, entsteht dabei intern ein neues String-Objekt, während das ursprüngliche unverändert bleibt. Dieses Verhalten trägt zur Sicherheit und Stabilität von Programmen bei, erfordert jedoch bei häufiger String-Manipulation gegebenenfalls den Einsatz spezieller Klassen wie StringBuilder, um die Performance des Programms nicht zu gefährden.

String-Literale

String-Literale

• Folge von Unicode-Zeichen
• umschlossen von doppelten Anführungszeichen "

Bestimmte Sonderzeichen müssen speziell notiert (escaped) werden (vgl. Zeichenliterale)

Escape-Sequenz	Bedeutung
\"	Anführungszeichen '
\\	Backslash \
\t	Tabulator
\n	Zeilenvorschub (newline)
\r	Wagenrücklauf (carriage return)
\b	Backspace
\f	Seitenvorschub (form feed)

Ein String-Literal ist in Java eine feste, direkt im Quellcode angegebene Zeichenkette, die in doppelten Anführungszeichen steht, zum Beispiel "Hallo Welt". Es handelt sich dabei um ein String-Literale sind unveränderlich und werden von Java wiederverwendet, wenn identische Literale mehrfach im Programm vorkommen, was Speicher spart und die Effizienz erhöht.

String als Referenzdatentyp

• Deklaration einer Referenzvariable für einen String
  String variable;
• Inhalt der Variable ist nach der Deklaration undefiniert
• Erzeugung eines Strings
• über ein Literal
  variable = "INHALT";
• über new String()
variable = new String("INHALT");
• Kombination aus Zuweisung und Erzeugung
  String variable = "INHALT";

In Java ist ein String ein Referenzdatentyp, das bedeutet, dass eine String-Variable nicht direkt den Text selbst speichert, sondern eine Referenz auf ein String-Objekt im Speicher enthält. Die Deklaration einer solchen Referenzvariable erfolgt zum Beispiel durch String variable;. Nach dieser Deklaration ist der Inhalt der Variable noch undefiniert, das heißt, sie zeigt noch auf kein konkretes String-Objekt, da sie nicht initialisiert wurde.

Ein String-Objekt kann anschließend auf zwei Arten erzeugt und der Variablen zugewiesen werden: Entweder durch die Zuweisung eines String-Literals, wie zum Beispiel variable = "INHALT";, oder durch die explizite Erzeugung eines neuen Objekts mittels des Konstruktors, also variable = new String("INHALT");.

Oft werden Deklaration und Zuweisung auch kombiniert, sodass man eine Referenzvariable sofort mit einem String-Literal initialisiert, beispielsweise: String variable = "INHALT";.

Verkettung von Strings

Verkettung (concatenation)

• Strings können mit + zu neuen Strings verkettet werden
• Strings können mit + mit anderen Datentypen verkettet werden
• Ergebnis ist ein neuer String im Speicher
• Auswertung erfolgt strikt von links nach rechts

Verkettung von Strings

Java können Strings mithilfe des Plus-Operators (+) zu neuen Zeichenketten verkettet werden. Diese Art der Verkettung ist besonders praktisch und wird häufig verwendet, um längere Texte dynamisch zusammenzusetzen. Dabei können sowohl zwei Strings miteinander verbunden werden, als auch ein String mit einem anderen Datentyp wie etwa einer Zahl (z. B. int, double). Java wandelt dabei automatisch nicht-String-Typen in ihre String-Darstellung um, bevor die Verkettung erfolgt.

Ein wichtiges Merkmal der String-Verkettung ist, dass das Ergebnis stets ein neuer String im Speicher ist. Da Strings in Java unveränderlich (immutable) sind, wird bei jeder Verkettung eine neue Instanz erzeugt, selbst wenn ein vorhandener String erneut verwendet wird. Dies kann bei sehr vielen Verkettungen innerhalb von Schleifen zu Performance-Problemen führen.

Die Auswertung einer Verkettung erfolgt in Java strikt von links nach rechts. Das bedeutet, dass Java bei einer längeren Verkettung Schritt für Schritt von links beginnt und die einzelnen Teile nacheinander zusammenfügt. Dieses Verhalten kann Auswirkungen auf das Ergebnis haben, insbesondere wenn unterschiedliche Datentypen beteiligt sind. Zum Beispiel ergibt der Ausdruck 1 + 2 + "3" den String "33", denn 1 + 2 wird zuerst zu 3 berechnet, und dann wird "3" als String angehängt. Umgekehrt würde der Ausdruck "1" + 2 + 3 direkt den String "123" ergeben, da nach der ersten Verkettung alles Weitere ebenfalls als String behandelt wird.

String a = "Hallo" + " " + "Welt";
System.out.println(a); // -> Hallo Welt

String b = "Antwort=" + 42;
System.out.println(b); // -> Antwort=42

String c = "Antwort=" + 39 + 3;
System.out.println(c); // -> Antwort=393

String d = "Antwort=" + (39 + 3);
System.out.println(d); // -> Antwort=42

String e = 39 + 3 + " ist die Antwort";
System.out.println(e); // -> 42 ist die Antwort

Methoden von String

String ist ein abstrakter Datentyp und bringt eine Reihe von Methoden mit

• Methoden verändern nie den Inhalt des Strings, sondern erzeugen einen neuen String
• Werden über den Punkt-Operator (.) aufgerufen
  Syntax: variable.methode()

Methode	Rückgabe	Zweck
length()	int	Länge des Strings in Zeichen zurückgeben
charAt(int i)	char	Zeichen an der Stelle i zurückgeben
substring(int start)	String	Teil-String ab der Stelle start

String test = "Hallo Java";

// Laenge des Strings
System.out.println(test.length()); // -> 10

// Zeichen an Stelle 6 (Zaehlung beginnt bei 0)
System.out.println(test.charAt(6)); // -> J

// Teilstring ab Stelle 6 (Zaehlung beginnt bei 0)
System.out.println(test.substring(6)); // -> Java

Vergleich von Strings

Strings und Referenzdatentypen vergleicht man nicht mit ==

Strings werden nicht mit == verglichen, sondern mit einer speziellen Methode equals()

String film1 = "Pulp Fiction";
String film2 = "Pulp Fiction";

System.out.println(film1.equals(film2)); // -> true

Würde man den Vergleich mit == durchführen, kommt in manchen Fällen true in den meisten Fällen aber false heraus.

String film1 = "Pulp Fiction";
String film2 = "Pulp Fiction";
String film3 = new String("Pulp Fiction");

System.out.println(film1.equals(film2)); // -> true
System.out.println(film1.equals(film3)); // -> true
System.out.println(film1 == film2); // -> true
System.out.println(film1 == film3); // -> false

In Java sollte man Strings nicht mit == vergleichen, weil == nur prüft, ob zwei Referenzen auf dasselbe Objekt im Speicher zeigen, nicht, ob die Inhalte der Strings gleich sind.

Java verwendet eine String-Literaloptimierung: Alle String-Literale (z. B. "hallo") werden nur einmal im sogenannten String-Pool gespeichert. Wenn man schreibt:

String film1 = "Pulp Fiction";
String film2 = "Pulp Fiction";

zeigen beide Variablen auf dasselbe Objekt im String-Pool, deshalb ist film1 == film2 hier true.

Sobald ein String zur Laufzeit erzeugt wird (z. B. mit String film3 = new String("Pulp Fiction"), per Eingabe oder durch String-Verkettung), landet er nicht automatisch im Pool und == liefert dann false, obwohl die Inhalte gleich sein können, sodass film1 == film3 hier false ergibt.