In Java ist `String` eine vordefinierte Klasse, die verwendet wird, um Zeichenketten darzustellen. Eine Zeichenkette ist eine Sequenz von Zeichen, wie Buchstaben, Zahlen oder Sonderzeichen. Zeichenketten werden in Java häufig verwendet, um Texte, Wörter, Sätze und andere textbasierte Informationen zu speichern und zu manipulieren.
Die `String`-Klasse in Java ist Teil des `java.lang`-Pakets und ist eine der wichtigsten und am häufigsten verwendeten Klassen in der Java Standardbibliothek. Da die `String`-Klasse so grundlegend ist, wird sie automatisch importiert, wenn Sie Java-Code schreiben, sodass Sie sie ohne zusätzlichen Import verwenden können.
Einige wichtige Merkmale der `String`-Klasse in Java sind:
1. Unveränderlichkeit: Instanzen der `String`-Klasse sind unveränderlich, d.h., sobald eine Zeichenkette erstellt wurde, kann ihr Wert nicht geändert werden. Wenn Sie Änderungen an einer `String`-Instanz vornehmen, wird tatsächlich eine neue `String`-Instanz erzeugt.
2. String-Literal: In Java können Sie Zeichenketten als String-Literal (Zeichenkette in doppelten Anführungszeichen) darstellen. Beispiel: `"Hello, World!"`
3. Methoden zur Zeichenkettenmanipulation: Die `String`-Klasse bietet eine Vielzahl von Methoden zur Manipulation und Verarbeitung von Zeichenketten. Dazu gehören Methoden zum Vergleichen von Zeichenketten, zum Ersetzen von Zeichen, zum Konvertieren von Groß-/Kleinschreibung, zum Extrahieren von Teilzeichenketten, zum Suchen von Zeichen oder Substrings, zur Umwandlung von Zeichenketten in Arrays usw. Beispiel:
public class Main {
public static void main(String[] args) {
String message = "Hello, Java!";
System.out.println("Länge der Zeichenkette: " + message.length());
System.out.println("Zeichen an Index 3: " + message.charAt(3));
System.out.println("Index von 'J': " + message.indexOf('J'));
System.out.println("Teilzeichenkette von Index 7 bis 11: " + message.substring(7, 12));
System.out.println("Zeichenkette in Großbuchstaben: " + message.toUpperCase());
System.out.println("Zeichenkette in Kleinbuchstaben: " + message.toLowerCase());
}
}
4. Concatenation: Sie können Zeichenketten durch die `+`-Operator verketten. Beispiel:
String firstName = "John";
String lastName = "Doe";
String fullName = firstName + " " + lastName;
System.out.println(fullName); // Ausgabe: "John Doe"
Die `String`-Klasse ist aufgrund ihrer Vielseitigkeit und der verfügbaren Methoden eine leistungsstarke Klasse für die Arbeit mit Zeichenketten in Java. Da sie unveränderlich ist, bietet sie auch eine erhöhte Sicherheit und Thread-Sicherheit in multithreading-ähnlichen Umgebungen.
`StringBuilder` ist eine Klasse in Java, die verwendet wird, um effizient Zeichenketten zu erstellen und zu manipulieren. Im Gegensatz zur `String`-Klasse, die unveränderlich ist, ermöglicht `StringBuilder` die Änderung von Zeichenketten, ohne dass dabei neue Objekte erstellt werden müssen. Dadurch ist `StringBuilder` in vielen Fällen schneller und ressourcenschonender als die Verwendung von `String` für die Zeichenkettenmanipulation.
Die `StringBuilder`-Klasse gehört zum Paket `java.lang` und ist eine der Standardklassen in der Java Standardbibliothek. Ähnlich wie bei `String` können Sie die `StringBuilder`-Klasse ohne zusätzlichen Import in Ihrem Java-Code verwenden.
Einige wichtige Merkmale und Methoden der `StringBuilder`-Klasse sind:
1. Veränderlichkeit: `StringBuilder`-Objekte sind veränderlich, was bedeutet, dass Sie den Inhalt einer `StringBuilder`-Instanz ändern können, ohne eine neue Instanz zu erzeugen.
2. Methoden zur Zeichenkettenmanipulation: Die `StringBuilder`-Klasse bietet eine Vielzahl von Methoden zur Manipulation und Verarbeitung von Zeichenketten. Dazu gehören Methoden zum Anhängen von Zeichen oder Zeichenketten, zum Ersetzen von Zeichen, zum Löschen von Teilen der Zeichenkette, zum Einfügen von Zeichen oder Zeichenketten an bestimmten Positionen, zur Umwandlung von Zeichenketten in Arrays usw.
Beispiel:
public class Main {
public static void main(String[] args) {
StringBuilder builder = new StringBuilder("Hello");
// Zeichen anhängen
builder.append(", Java!");
// Zeichen ersetzen
builder.replace(5, 9, "World");
// Teilzeichenkette löschen
builder.delete(0, 6);
System.out.println(builder.toString()); // Ausgabe: "World, Java!"
}
}
3. Leistung und Effizienz: Da `StringBuilder` veränderlich ist und keine neuen Objekte erstellt werden müssen, wenn Sie Änderungen an der Zeichenkette vornehmen, ist sie oft effizienter als die Verwendung von `String` in Szenarien, in denen Sie viele Zeichenkettenmanipulationen durchführen.
4. Thread-Sicherheit: Im Gegensatz zu `StringBuffer` ist `StringBuilder` nicht thread-sicher. Das bedeutet, dass `StringBuilder` nicht für Anwendungen verwendet werden sollte, die in multithreading-ähnlichen Umgebungen laufen, es sei denn, Sie ergreifen selbst geeignete Maßnahmen zur Synchronisierung.
Beispiel:
import java.util.concurrent.*;
public class Main {
public static void main(String[] args) {
StringBuilder builder = new StringBuilder();
Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
builder.append("a"); // Nicht thread-sicher!
}
};
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(task);
executor.submit(task);
executor.shutdown();
try {
executor.awaitTermination(1, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(builder.length()); // Erwartete Ausgabe: 2000 (kann variieren)
}
}
Insgesamt ist `StringBuilder` eine nützliche Klasse in Java, wenn Sie effizient mit veränderlichen Zeichenketten arbeiten möchten. Wenn Sie jedoch in einer Thread-orientierten Umgebung arbeiten, sollten Sie `StringBuffer` verwenden, da es thread-sicher ist, obwohl es etwas langsamer sein kann als `StringBuilder`.
Aufgabe 1:
In einer Datenbank befinden sich viele Namen, die sortiert ausgegeben werden sollen. Überprüfen Sie mithilfe der Funktion `compareTo`, ob die Namen "Meier" und "Mayer" korrekt sortiert werden. Anschließend sollen die Namen in sortierter Reihenfolge ausgegeben werden.
Augabe 2:
Der Satz "Java ist eine Insel" soll einmal nur mit kleinen Buchstaben und einmal nur mit großen Buchstaben ausgegeben werden.
Aufgabe 3:
- Erstellen Sie eine Methode begruesung mit den Parametern name (String) und geschlecht (String).
- Überprüfen Sie innerhalb der Methode das Geschlecht und geben Sie den entsprechenden Begrüßungssatz zurück:
- Wenn das Geschlecht "weiblich" ist, geben Sie "Sehr geehrte Frau" gefolgt vom Namen zurück.
- Im anderen Fall geben Sie "Sehr geehrter Herr" gefolgt vom Namen zurück.
- Ergebnis: Sehr geehrte Frau + name / Sehr geehrter Herr + name
Aufgabe 4:
- Wie viele Buchstaben hat der Text "Wir gratulieren Ihnen zur erfolgreichen Lösung der Übungsaufgabe."?
- Enthält das Wort erfolg?
- Wie viele 'a' enthält der Text?
Aufgabe 5:
Eine Funktion soll eine Zahl als Parameter nehmen und mit `StringBuilder` diesen Satz aufbauen: Nutzen Sie die Funktionen "replace und insert"
- Sie haben erfolgreich die Prüfung mit der Note 1 bestanden.
- Sie haben leider die Prüfung mit der Note 5 nicht bestanden.
Aufgabe 6:
Gegeben sei dieser String. Entnehmen Sie die Zahlen und berechnen Sie den Durchschnitt der Noten:
String s= "Sie haben in Mathe die Note 1, in Physik die Note 2 und in Geschichte die Note 3."
Ihre Durchschnittsnote ist: 2