Sequenzen von Zeichen — indexiert, immutable, end ist exklusiv. substring, indexOf, replace, split — die 80%-Operationen jeder Programmieraufgabe. Mit String-Lab und animiertem indexOf.
Ein String ist eine Zeichenkette, also eine geordnete Folge von Buchstaben, Ziffern und Sonderzeichen. Klausurrelevant ist vor allem die String-Manipulation: Suchen, Splitten, Vergleichen, Konvertieren.
Die wichtigsten Operationen die du in der Klausur kennen musst:
s.length() in Java, len(s) in Pythons.charAt(i) (Java) oder s[i] (Python), null-basierts.equals(other) in Java (== vergleicht Referenzen!), s == other in Pythons.contains(x), s.indexOf(x), s.startsWith(x)s.split(",") und String.join(",", arr)s.replace() gibt neuen String zurückIn Klausuren ist die häufigste Falle: s == "hallo" in Java vergleicht Referenzen, nicht den Inhalt. Immer s.equals("hallo") benutzen. Plus: Off-by-one bei charAt(s.length()) wirft StringIndexOutOfBoundsException.
Du musst:
Alle vier Aufgaben sind String-Manipulation. Die meisten Klausurfragen in den ersten Programmierwochen drehen sich darum.
Ein String ist eine Sequenz von Zeichen — wie ein Array von Buchstaben. In Java:
String. In Python:str.
Index: 0 1 2 3 4
Zeichen: H a l l o
Das erste Zeichen hat Index 0, das letzte Index length − 1. Klassisches Off-by-one-Problem.
String s = "Hallo";
System.out.println(s.length()); // 5
System.out.println(s.charAt(0)); // 'H'
System.out.println(s.charAt(4)); // 'o'
System.out.println(s.charAt(5)); // !! StringIndexOutOfBoundsException
In Python geht's mit Klammern wie bei Listen:
s = "Hallo"
print(len(s)) # 5
print(s[0]) # 'H'
print(s[-1]) # 'o' (von hinten zählen)
print(s[5]) # IndexError
Python erlaubt negative Indizes —
s[-1]ist das letzte Zeichen,s[-2]das vorletzte. Java nicht.
"Hallo".length() // 5
len("Hallo") # 5
Bekommst einen Teil-String. Achtung — end ist EXKLUSIV (geht bis aber nicht inklusive).
String s = "Hallo Welt";
s.substring(0, 5); // "Hallo" (Index 0,1,2,3,4 — NICHT 5)
s.substring(6, 10); // "Welt"
s.substring(6); // "Welt" (ohne end → bis zum Ende)
s = "Hallo Welt"
s[0:5] # "Hallo"
s[6:10] # "Welt"
s[6:] # "Welt" (ohne end → bis Ende)
s[:5] # "Hallo" (ohne start → ab Anfang)
Python-Slicing ist mächtiger:
s[::2]jedes zweite,s[::-1]reversed.
"Hallo" + " " + "Welt" // "Hallo Welt"
"Hallo" + " " + "Welt" # "Hallo Welt"
"Hallo Welt".indexOf("Welt") // 6
"Hallo Welt".indexOf("xyz") // -1 (nicht gefunden)
"Hallo Welt".find("Welt") # 6
"Hallo Welt".find("xyz") # -1
"Welt" in "Hallo Welt" # True (einfacher!)
"Hallo Welt".replace("Welt", "Du") // "Hallo Du"
"Hallo Welt".replace("Welt", "Du") # "Hallo Du"
"Hallo".toUpperCase() // "HALLO"
"Hallo".toLowerCase() // "hallo"
"Hallo".upper() # "HALLO"
"Hallo".lower() # "hallo"
String[] parts = "a,b,c".split(","); // ["a", "b", "c"]
String joined = String.join("-", parts); // "a-b-c"
parts = "a,b,c".split(",") # ["a", "b", "c"]
joined = "-".join(parts) # "a-b-c"
In Java und Python sind Strings unveränderlich. Jede Operation liefert einen neuen String — der Original bleibt.
String s = "hallo";
s.toUpperCase(); // gibt "HALLO" zurück, aber...
System.out.println(s); // "hallo" — s unverändert!
s = s.toUpperCase(); // muss neu zugewiesen werden
System.out.println(s); // "HALLO"
s = "hallo"
s.upper() # gibt "HALLO" zurück...
print(s) # "hallo" — s unverändert!
s = s.upper() # muss neu zugewiesen werden
print(s) # "HALLO"
Klausur-Falle:
s.toUpperCase()allein verändert nichts — du musst das Ergebnis wieder zuweisen.
Jedes + erzeugt einen NEUEN String. In einer Schleife mit 1000 Konkatenationen → 1000 neue Strings → O(n²).
// SCHLECHT — O(n²)
String s = "";
for (int i = 0; i < 1000; i++) {
s = s + i; // jedes mal neuer String
}
// GUT — O(n)
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
sb.append(i);
}
String s = sb.toString();
In Python: gleicher Trick mit Liste + "".join(...):
parts = []
for i in range(1000):
parts.append(str(i))
s = "".join(parts)
In Java EXTREMER Klausur-Klassiker:
String a = "Hallo";
String b = "Hallo";
String c = new String("Hallo");
a == b // ⚠ kann true sein (String-Pool), aber NIE darauf verlassen
a == c // FALSE — anderes Objekt im Heap
a.equals(b) // true
a.equals(c) // true
Regel: in Java IMMER
.equals()für Strings — niemals==.==vergleicht die Referenz (sind es dasselbe Objekt?),.equals()vergleicht den Inhalt.
In Python: == vergleicht den Inhalt, is vergleicht Referenzen.
a = "Hallo"
b = "Hallo"
a == b # True — vergleicht Inhalt (häufig richtig)
a is b # häufig True (Interning), aber UNVERLÄSSLICH
In Java unterscheidet man:
char c = 'A'; // einzelnes Zeichen, Apostrophs
String s = "A"; // String der Länge 1, Anführungszeichen
char ist ein primitiver Typ, intern eine Zahl (Unicode-Codepoint)String ist ein ObjektIn Python gibt es keinen char-Typ — s[0] liefert wieder einen String der Länge 1.
s = "Hallo"
type(s[0]) # <class 'str'>
Trick 1 — Off-by-one bei Indizes: Index läuft 0..length−1, nicht 1..length. s.charAt(s.length()) ist Exception.
Trick 2 — substring(start, end) ist EXKLUSIV: "Hallo".substring(1, 4) → "all", NICHT "alli". Wenn du n Zeichen ab Position k willst → substring(k, k+n).
Trick 3 — In Java IMMER .equals(), niemals == für String-Vergleich. Klausuren testen das jedes Semester.
Trick 4 — Strings immutable: s.toUpperCase() allein ändert s nicht. s = s.toUpperCase().
Trick 5 — indexOf liefert -1 wenn nicht gefunden: niemals an Index −1 zugreifen.
int i = s.indexOf("foo");
if (i != -1) {
s.charAt(i); // sicher
}
Trick 6 — Palindrom-Klassiker: ein String liest sich vorwärts wie rückwärts.
boolean isPalindrom(String s) {
return s.equals(new StringBuilder(s).reverse().toString());
}
// Smarter: zwei Pointer
boolean isPalindrom2(String s) {
int i = 0, j = s.length() - 1;
while (i < j) {
if (s.charAt(i) != s.charAt(j)) return false;
i++; j--;
}
return true;
}
Trick 7 — Anagramm-Klassiker: zwei Strings sind Anagramme wenn sie dieselben Zeichen in beliebiger Reihenfolge enthalten.
boolean isAnagram(String a, String b) {
if (a.length() != b.length()) return false;
char[] ca = a.toCharArray();
char[] cb = b.toCharArray();
Arrays.sort(ca);
Arrays.sort(cb);
return Arrays.equals(ca, cb);
}
Trick 8 — Whitespace und trim(): " Hallo ".trim() → "Hallo". Klausurfrage zur User-Eingabe-Säuberung.
Trick 9 — Encoding: ASCII (128 Zeichen, 7 Bit) vs. UTF-8 (variable Länge, alle Sprachen). Java intern UTF-16, ein char = 2 Bytes. Spezielle Zeichen wie Emoji brauchen 2 chars.
Faustregel: Strings sind 80 % von dem, was du als Programmieranfänger anfasst. Lerne die wichtigsten Methoden auswendig — substring, indexOf, replace, split, equals.
Alle Tabs der Lerneinheit (Erklärung · Interaktiv · Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur — und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Ein String ist eine Zeichenkette, also eine geordnete Folge von Buchstaben, Ziffern und Sonderzeichen. Klausurrelevant ist vor allem die String-Manipulation: Suchen, Splitten, Vergleichen, Konvertieren.
Die wichtigsten Operationen die du in der Klausur kennen musst:
Wie speichert ein Programm Werte? Wie unterscheiden sich int, double, String und boolean?
if, else, else if. Wie trifft ein Programm Entscheidungen, und welche Vergleichsoperatoren brauchst du?
for, while, Iteration. Wie wiederhole ich Code, ohne mich zu verzetteln?
s.length() in Java, len(s) in Pythons.charAt(i) (Java) oder s[i] (Python), null-basierts.equals(other) in Java (== vergleicht Referenzen!), s == other in Pythons.contains(x), s.indexOf(x), s.startsWith(x)s.split(",") und String.join(",", arr)s.replace() gibt neuen String zurückIn Klausuren ist die häufigste Falle: s == "hallo" in Java vergleicht Referenzen, nicht den Inhalt. Immer s.equals("hallo") benutzen. Plus: Off-by-one bei charAt(s.length()) wirft StringIndexOutOfBoundsException.
Du musst:
Alle vier Aufgaben sind String-Manipulation. Die meisten Klausurfragen in den ersten Programmierwochen drehen sich darum.
Ein String ist eine Sequenz von Zeichen — wie ein Array von Buchstaben. In Java:
String. In Python:str.
Index: 0 1 2 3 4
Zeichen: H a l l o
Das erste Zeichen hat Index 0, das letzte Index length − 1. Klassisches Off-by-one-Problem.
String s = "Hallo";
System.out.println(s.length()); // 5
System.out.println(s.charAt(0)); // 'H'
System.out.println(s.charAt(4)); // 'o'
System.out.println(s.charAt(5)); // !! StringIndexOutOfBoundsException
In Python geht's mit Klammern wie bei Listen:
s = "Hallo"
print(len(s)) # 5
print(s[0]) # 'H'
print(s[-1]) # 'o' (von hinten zählen)
print(s[5]) # IndexError
Python erlaubt negative Indizes —
s[-1]ist das letzte Zeichen,s[-2]das vorletzte. Java nicht.
"Hallo".length() // 5
len("Hallo") # 5
Bekommst einen Teil-String. Achtung — end ist EXKLUSIV (geht bis aber nicht inklusive).
String s = "Hallo Welt";
s.substring(0, 5); // "Hallo" (Index 0,1,2,3,4 — NICHT 5)
s.substring(6, 10); // "Welt"
s.substring(6); // "Welt" (ohne end → bis zum Ende)
s = "Hallo Welt"
s[0:5] # "Hallo"
s[6:10] # "Welt"
s[6:] # "Welt" (ohne end → bis Ende)
s[:5] # "Hallo" (ohne start → ab Anfang)
Python-Slicing ist mächtiger:
s[::2]jedes zweite,s[::-1]reversed.
"Hallo" + " " + "Welt" // "Hallo Welt"
"Hallo" + " " + "Welt" # "Hallo Welt"
"Hallo Welt".indexOf("Welt") // 6
"Hallo Welt".indexOf("xyz") // -1 (nicht gefunden)
"Hallo Welt".find("Welt") # 6
"Hallo Welt".find("xyz") # -1
"Welt" in "Hallo Welt" # True (einfacher!)
"Hallo Welt".replace("Welt", "Du") // "Hallo Du"
"Hallo Welt".replace("Welt", "Du") # "Hallo Du"
"Hallo".toUpperCase() // "HALLO"
"Hallo".toLowerCase() // "hallo"
"Hallo".upper() # "HALLO"
"Hallo".lower() # "hallo"
String[] parts = "a,b,c".split(","); // ["a", "b", "c"]
String joined = String.join("-", parts); // "a-b-c"
parts = "a,b,c".split(",") # ["a", "b", "c"]
joined = "-".join(parts) # "a-b-c"
In Java und Python sind Strings unveränderlich. Jede Operation liefert einen neuen String — der Original bleibt.
String s = "hallo";
s.toUpperCase(); // gibt "HALLO" zurück, aber...
System.out.println(s); // "hallo" — s unverändert!
s = s.toUpperCase(); // muss neu zugewiesen werden
System.out.println(s); // "HALLO"
s = "hallo"
s.upper() # gibt "HALLO" zurück...
print(s) # "hallo" — s unverändert!
s = s.upper() # muss neu zugewiesen werden
print(s) # "HALLO"
Klausur-Falle:
s.toUpperCase()allein verändert nichts — du musst das Ergebnis wieder zuweisen.
Jedes + erzeugt einen NEUEN String. In einer Schleife mit 1000 Konkatenationen → 1000 neue Strings → O(n²).
// SCHLECHT — O(n²)
String s = "";
for (int i = 0; i < 1000; i++) {
s = s + i; // jedes mal neuer String
}
// GUT — O(n)
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
sb.append(i);
}
String s = sb.toString();
In Python: gleicher Trick mit Liste + "".join(...):
parts = []
for i in range(1000):
parts.append(str(i))
s = "".join(parts)
In Java EXTREMER Klausur-Klassiker:
String a = "Hallo";
String b = "Hallo";
String c = new String("Hallo");
a == b // ⚠ kann true sein (String-Pool), aber NIE darauf verlassen
a == c // FALSE — anderes Objekt im Heap
a.equals(b) // true
a.equals(c) // true
Regel: in Java IMMER
.equals()für Strings — niemals==.==vergleicht die Referenz (sind es dasselbe Objekt?),.equals()vergleicht den Inhalt.
In Python: == vergleicht den Inhalt, is vergleicht Referenzen.
a = "Hallo"
b = "Hallo"
a == b # True — vergleicht Inhalt (häufig richtig)
a is b # häufig True (Interning), aber UNVERLÄSSLICH
In Java unterscheidet man:
char c = 'A'; // einzelnes Zeichen, Apostrophs
String s = "A"; // String der Länge 1, Anführungszeichen
char ist ein primitiver Typ, intern eine Zahl (Unicode-Codepoint)String ist ein ObjektIn Python gibt es keinen char-Typ — s[0] liefert wieder einen String der Länge 1.
s = "Hallo"
type(s[0]) # <class 'str'>
Trick 1 — Off-by-one bei Indizes: Index läuft 0..length−1, nicht 1..length. s.charAt(s.length()) ist Exception.
Trick 2 — substring(start, end) ist EXKLUSIV: "Hallo".substring(1, 4) → "all", NICHT "alli". Wenn du n Zeichen ab Position k willst → substring(k, k+n).
Trick 3 — In Java IMMER .equals(), niemals == für String-Vergleich. Klausuren testen das jedes Semester.
Trick 4 — Strings immutable: s.toUpperCase() allein ändert s nicht. s = s.toUpperCase().
Trick 5 — indexOf liefert -1 wenn nicht gefunden: niemals an Index −1 zugreifen.
int i = s.indexOf("foo");
if (i != -1) {
s.charAt(i); // sicher
}
Trick 6 — Palindrom-Klassiker: ein String liest sich vorwärts wie rückwärts.
boolean isPalindrom(String s) {
return s.equals(new StringBuilder(s).reverse().toString());
}
// Smarter: zwei Pointer
boolean isPalindrom2(String s) {
int i = 0, j = s.length() - 1;
while (i < j) {
if (s.charAt(i) != s.charAt(j)) return false;
i++; j--;
}
return true;
}
Trick 7 — Anagramm-Klassiker: zwei Strings sind Anagramme wenn sie dieselben Zeichen in beliebiger Reihenfolge enthalten.
boolean isAnagram(String a, String b) {
if (a.length() != b.length()) return false;
char[] ca = a.toCharArray();
char[] cb = b.toCharArray();
Arrays.sort(ca);
Arrays.sort(cb);
return Arrays.equals(ca, cb);
}
Trick 8 — Whitespace und trim(): " Hallo ".trim() → "Hallo". Klausurfrage zur User-Eingabe-Säuberung.
Trick 9 — Encoding: ASCII (128 Zeichen, 7 Bit) vs. UTF-8 (variable Länge, alle Sprachen). Java intern UTF-16, ein char = 2 Bytes. Spezielle Zeichen wie Emoji brauchen 2 chars.
Faustregel: Strings sind 80 % von dem, was du als Programmieranfänger anfasst. Lerne die wichtigsten Methoden auswendig — substring, indexOf, replace, split, equals.
Tipp einen String ein und probier die Operationen aus:
Probier folgendes:
Interaktive Visualisierung
Live-Lab für String-Operationen (substring, indexOf, replace, split) mit Index-Highlight.
Faustregel zum Mitnehmen: Strings sind indexierte Zeichensequenzen, immutable, und end ist exklusiv. Drei Klausur-Klassiker auf einen Blick.
Klausurfragen mit Lösungen (8)
Antwort: 'H'
Erklärung: Strings sind 0-indexiert — das erste Zeichen hat Index 0. charAt(0) liefert das primitive char 'H' (mit einfachen Anführungszeichen). Achtung: charAt(5) bei einem 5-Zeichen-String wäre IndexOutOfBounds.
Antwort: "Hallo"
Erklärung: substring(start, end) ist start INKLUSIV und end EXKLUSIV. Index 0,1,2,3,4 → 'Hallo'. Index 5 wäre das Leerzeichen, ist aber NICHT enthalten. Klassischer Klausur-Trick.
Antwort: Operationen liefern neue Strings, der Original bleibt unverändert
Erklärung: Strings sind immutable — jede Operation (toUpperCase, replace, substring) liefert einen NEUEN String, der originale bleibt. Deshalb muss man oft 's = s.toUpperCase()' schreiben, sonst geht das Ergebnis verloren.
Antwort: a.equals(b)
Erklärung: .equals() vergleicht den INHALT. == vergleicht die Referenz (zwei Variablen, die auf das gleiche Objekt zeigen). Wegen String-Pool ist == oft zufällig true, aber NICHT VERLÄSSLICH. Klausur-Klassiker: niemals == für Strings in Java.
Antwort: -1
Erklärung: indexOf liefert −1 wenn der Suchstring nicht gefunden wird. Daher der Idiom-Check 'if (s.indexOf(...) != -1)'. Auf −1 als Index zugreifen wäre dann StringIndexOutOfBounds.
Antwort: O(n · m)
Erklärung: Naives indexOf prüft an jeder der ~n Positionen, ob die nächsten m Zeichen passen — also bis zu n·m Vergleiche. Bessere Algorithmen wie KMP oder Boyer-Moore schaffen O(n+m). Java's indexOf ist intern naiv, Python's find auch.
Antwort: Strings sind immutable — jedes + erzeugt einen NEUEN String, Schleife wird O(n²)
Erklärung: Wegen Immutability erzeugt jedes + einen kompletten neuen String. In einer Schleife mit 1000 Iterationen: 1000 neue Strings, jeder kopiert den alten — O(n²). Lösung: StringBuilder in Java, ''.join(list) in Python.
Antwort: Ein String-Array/Liste: ['Hallo', 'Welt']
Erklärung: split teilt den String am Trennzeichen und liefert ein Array (Java: String[]) bzw. eine Liste (Python: list). Häufig genutzt für Tokenisierung von Eingaben oder CSV-Parsing. Umkehr: String.join(...) bzw. ''.join(...).
Methoden, Parameter, Rückgabewerte. Code, der wiederverwendbar wird.