contains() in Java meistern: So führen Sie effiziente Teilstring‑Suchen durch

.## 1. Einführung: Warum die String‑Suche in Java wichtig ist

String‑Manipulation ist einer der am häufigsten genutzten Vorgänge beim Programmieren in Java.
Ob beim Prüfen von Benutzereingaben, beim Parsen von Dateiinhalten oder beim Suchen nach bestimmten Schlüsselwörtern – häufig muss ermittelt werden, ob ein bestimmtes Wort in einem gegebenen String enthalten ist.

Um diesen Bedarf zu decken, stellt Java die praktische Methode contains() bereit.
Mit dieser Methode lässt sich leicht bestimmen, ob ein String teilweise einen anderen enthält.
Beispielsweise kann man mit contains() prüfen, ob eine Fehlermeldung ein bestimmtes Schlüsselwort enthält – und das in einer einzigen Code‑Zeile.

Besonders in Szenarien mit großen Textmengen – etwa Web‑Anwendungen, API‑Verarbeitung oder Log‑Analyse – verbessert die contains()‑Methode die Lesbarkeit und Wartbarkeit des Codes erheblich.
Gleichzeitig gibt es wichtige Aspekte zu beachten, wie die Groß‑/Kleinschreibung und die Möglichkeit eines null‑Werts.

Dieser Artikel erklärt die Java‑Methode contains() im Detail – von der Grundsyntax über häufige Fehler bis hin zu Unterschieden zu anderen Methoden und praktischen Anwendungsfällen.
Unser Ziel ist es, nützliche Informationen sowohl für Einsteiger als auch für Entwickler zu liefern, die Java in realen Projekten einsetzen.

2. Grundsyntax und Eigenschaften der contains()‑Methode

Die Java‑Methode contains() bestimmt, ob ein String teilweise einen anderen String enthält.
Ihre Syntax ist sehr einfach, sie ist jedoch äußerst praktisch und wird häufig in alltäglichen Programmieraufgaben verwendet.

Grundsyntax

boolean result = targetString.contains(searchString);

Die Methode gehört zur Klasse String und akzeptiert ein CharSequence (üblicherweise ein String) als Argument.
Ihr Rückgabewert ist boolean: true, wenn der Ziel‑String die angegebene Teilzeichenkette enthält, und false sonst.

Beispielcode

String message = "Java programming is fun!";
boolean hasKeyword = message.contains("programming");

System.out.println(hasKeyword); // Output: true

Im obigen Beispiel ist die Teilzeichenkette "programming" im Ziel‑String enthalten, sodass contains() true zurückgibt.

Eigenschaften der Methode

• Prüft nur Teilübereinstimmungen: Wenn eine exakte Übereinstimmung nötig ist, verwenden Sie stattdessen equals().
• Groß‑/Kleinschreibung beachten: Zum Beispiel werden "Java" und "java" als unterschiedlich behandelt (Details werden später erklärt).
• Unterstützt keine regulären Ausdrücke: Da die Methode lediglich das Vorhandensein einer Zeichenkette prüft, erfordert das Muster‑Matching matches() oder die Klasse Pattern.

Verhalten bei Übergabe von null

Wird null an contains() übergeben, löst dies eine NullPointerException aus.
Beispielhaft wirft der folgende Code eine Ausnahme:

String text = null;
System.out.println(text.contains("test")); // Exception occurs

Ebenso wird dieselbe Ausnahme geworfen, wenn der Ziel‑String selbst null ist.
Daher wird dringend empfohlen, Null‑Prüfungen durchzuführen, bevor contains() aufgerufen wird.

3. Praktische Anwendungsbeispiele und wichtige Überlegungen

Die contains()‑Methode von Java ist sehr intuitiv und praktisch, doch falscher Einsatz kann zu unerwarteten Bugs oder ineffizientem Code führen.
Dieser Abschnitt erklärt die grundlegende Nutzung von contains() sowie zentrale Punkte, die Sie beachten sollten.

3‑1. Einfaches Anwendungsbeispiel

Der folgende Code demonstriert ein einfaches Beispiel, bei dem geprüft wird, ob der Ziel‑String ein bestimmtes Schlüsselwort enthält:

String sentence = "今日はJavaの勉強をしています。";

if (sentence.contains("Java")) {
    System.out.println("Javaが含まれています。");
} else {
    System.out.println("Javaは含まれていません。");
}

Wie zu sehen, wird contains() häufig mit if‑Anweisungen kombiniert, um bedingte Verzweigungen zu steuern.

3‑2. Groß‑/Kleinschreibung

Die contains()‑Methode ist groß‑/kleinschreibungssensitiv.
Zum Beispiel liefert der folgende Code false:

String text = "Welcome to Java";
System.out.println(text.contains("java")); // false

In solchen Fällen ist es üblich, die Zeichenketten vor dem Vergleich in Kleinbuchstaben (oder Großbuchstaben) zu konvertieren:

String text = "Welcome to Java";
System.out.println(text.toLowerCase().contains("java")); // true

Dieser Ansatz hilft, Unterschiede in der Eingabeschreibweise zu beseitigen (z. B. Benutzereingaben).

3-3. Umgang mit null und leeren Zeichenketten

Eine der wichtigsten Überlegungen bei der Verwendung von contains() ist der Umgang mit null.
Wenn entweder die Zielzeichenkette oder das Argument null ist, tritt eine NullPointerException auf.

String text = null;
System.out.println(text.contains("test")); // Runtime error

Um dieses Problem zu vermeiden, fügen Sie immer eine Nullprüfung hinzu:

if (text != null && text.contains("test")) {
    // Safe to process
}

Beachten Sie außerdem:
Das Übergeben einer leeren Zeichenkette ("") liefert immer true.

String sample = "test";
System.out.println(sample.contains("")); // true

Dieses Verhalten ist jedoch in der Praxis selten nützlich und kann unbeabsichtigt zu Fehlern führen, wenn leere Zeichenketten versehentlich übergeben werden.

3-4. Unterstützt keine Suche nach mehreren Schlüsselwörtern

contains() kann nur ein Schlüsselwort gleichzeitig prüfen.
Um mehrere Schlüsselwörter zu prüfen, müssen Sie entweder contains() mehrfach aufrufen oder die Stream-API verwenden.

String target = "エラーコード123：アクセス拒否";
if (target.contains("エラー") || target.contains("拒否")) {
    System.out.println("問題のあるメッセージです。");
}

Oder, für dynamische Schlüsselwortmengen:

List<String> keywords = Arrays.asList("エラー", "障害", "失敗");
boolean found = keywords.stream().anyMatch(target::contains);

4. Methoden, die häufig mit contains() verglichen werden

Java bietet mehrere Methoden zum Vergleichen von Zeichenketten oder zum Prüfen, ob ein bestimmter Teilstring existiert. Unter ihnen wird contains() für „Teilübereinstimmungen“ verwendet, aber andere Methoden dienen ebenfalls ähnlichen Zwecken. Dieser Abschnitt erklärt die Eigenschaften und Unterschiede dieser Methoden, damit Sie sie angemessen einsetzen können.

4-1. Unterschied zu equals(): Exakte Übereinstimmung vs. Teilübereinstimmung

equals() bestimmt, ob zwei Zeichenketten exakt identisch sind.
Im Gegensatz dazu prüft contains() Teilübereinstimmungen.

String a = "Java";
String b = "Java";

System.out.println(a.equals(b));      // true: Exact match
System.out.println(a.contains("av")); // true: Partial match

Hauptunterschiede:

Verwendungshinweis: Verwenden Sie equals(), wenn Werte exakt übereinstimmen müssen (z. B. ID‑Verifizierung). Verwenden Sie contains(), wenn Teilübereinstimmungen akzeptabel sind (z. B. Schlüsselwortsuche).

4-2. Unterschied zu indexOf(): Ob Sie die Position benötigen

Die Methode indexOf() kann ebenfalls verwendet werden, um zu prüfen, ob ein Teilstring in einer Zeichenkette vorkommt.
Der Unterschied besteht darin, dass indexOf() den Startindex des Teilstrings zurückgibt, falls er gefunden wird.
Wird der Teilstring nicht gefunden, gibt sie -1 zurück.

String text = "Hello, Java World!";
System.out.println(text.indexOf("Java"));    // 7
System.out.println(text.indexOf("Python"));  // -1

Sie können indexOf() auch verwenden, um das Verhalten von contains() nachzuahmen:

if (text.indexOf("Java") >= 0) {
    System.out.println("It is contained.");
}

Verwendungshinweis: Wenn Sie den Index nicht benötigen, ist contains() lesbarer und vorzuziehen.

4-3. Unterschied zu matches(): Unterstützung von regulären Ausdrücken

Die Methode matches() prüft, ob eine Zeichenkette vollständig einem angegebenen regulären Ausdruck entspricht.
Im Gegensatz dazu prüft contains() nur auf wörtliche Teilstring‑Übereinstimmungen und unterstützt keine regulären Ausdrücke.

String text = "abc123";
System.out.println(text.matches(".*123")); // true
System.out.println(text.contains(".*123")); // false (not regex)

Wenn Sie eine teilbasierte Übereinstimmung mit regulären Ausdrücken wünschen, verwenden Sie die Klasse Pattern:

4-4. Zusammenfassung des Funktionsvergleichs

5. Häufige Anwendungsfälle und Beispielcode

Java’s contains()‑Methode ist einfach, aber in realen Entwicklungsszenarien weit verbreitet.
Typische Anwendungsfälle umfassen die Validierung von Benutzereingaben, die Protokollanalyse und Filteroperationen.
Dieser Abschnitt behandelt praktische Beispiele mit zugehörigem Code.

5-1. Validierung von Benutzereingaben (Erkennung verbotener Wörter)

In Formularen oder Chat‑Anwendungen müssen Sie möglicherweise erkennen, ob bestimmte verbotene Wörter enthalten sind.

String input = "このアプリは最悪だ";
String banned = "最悪";

if (input.contains(banned)) {
    System.out.println("不適切な言葉が含まれています。");
}

Umgang mit mehreren NG‑Wörtern:

List<String> bannedWords = Arrays.asList("最悪", "バカ", "死ね");
for (String word : bannedWords) {
    if (input.contains(word)) {
        System.out.println("不適切な言葉が含まれています: " + word);
        break;
    }
}

5-2. Protokolldateianalyse (Erkennung spezifischer Meldungen)

Bei der Analyse von System‑ oder Anwendungsprotokollen möchten Sie möglicherweise nur Zeilen extrahieren, die bestimmte Schlüsselwörter wie ERROR oder WARN enthalten.

List<String> logs = Arrays.asList(
    "[INFO] サーバーが起動しました",
    "[ERROR] データベース接続失敗",
    "[WARN] メモリ使用率が高い"
);

for (String log : logs) {
    if (log.contains("ERROR")) {
        System.out.println("エラー発生ログ: " + log);
    }
}

5-3. Filtern von Zeichenketten in einer Liste (Verwendung der Stream‑API)

Bei der Verarbeitung großer Datensätze verwenden Sie die Stream‑API, um nur Elemente zu extrahieren, die eine bestimmte Teilzeichenkette enthalten:

List<String> users = Arrays.asList("tanaka@example.com", "sato@gmail.com", "yamada@yahoo.co.jp");

List<String> gmailUsers = users.stream()
    .filter(email -> email.contains("@gmail.com"))
    .collect(Collectors.toList());

System.out.println(gmailUsers); // [sato@gmail.com]

5-4. Parsen von HTTP‑Anforderungsheadern oder URLs

In der Webentwicklung können Routing oder gerätespezifische Verarbeitung das Prüfen von Teilzeichenketten im User‑Agent oder in der URL erfordern.

String userAgent = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X)";
if (userAgent.contains("iPhone")) {
    System.out.println("スマートフォンからのアクセスです。");
}

5-5. Überprüfen von Dateipfaden oder -erweiterungen

Um den Dateityp anhand seines Pfads zu bestimmen:

String filePath = "/usr/local/data/sample.csv";
if (filePath.contains(".csv")) {
    System.out.println("CSVファイルです。");
}

Hinweis:
Bei Prüfungen von Dateierweiterungen ist endsWith(".csv") oft genauer.

Praktische Überlegungen

• Wenden Sie Normalisierung an (z. B. toLowerCase(), trim()), wenn Genauigkeit erforderlich ist.
• Bei groß angelegten Daten sollten Sie die Stream‑API oder reguläre Ausdrücke in Betracht ziehen.
• Denken Sie daran, dass contains() eine Teilübereinstimmung ist – kombinieren Sie es mit anderen Bedingungen für sicherere Logik.

6. Leistungsüberlegungen

Obwohl die contains()‑Methode hervorragende Lesbarkeit und Einfachheit bietet, müssen Sie ihre Leistungswirkung berücksichtigen, wenn Sie große Datensätze verarbeiten oder wiederholte Vorgänge ausführen.
Dieser Abschnitt erklärt die Verarbeitungskosten von contains() und alternative Ansätze für verbesserte Effizienz.

6-1. Internes Verhalten und Zeitkomplexität von contains()

Die contains()‑Methode durchsucht die Zielzeichenkette sequenziell von Anfang an, um die Teilzeichenkette zu finden.
Intern nutzt sie die indexOf()‑Methode, und ihre Worst‑Case‑Zeitkomplexität beträgt:

O(n * m)
– n = Länge der Zielzeichenkette
– m = Länge der Suchzeichenkette

Beispiel für intensive Verarbeitung:

for (String line : hugeTextList) {
    if (line.contains("error")) {
        // processing
    }
}

Dies kann die Leistung erheblich beeinträchtigen, wenn es in großen Schleifen wiederholt wird.

6-2. Techniken zur Leistungsverbesserung bei häufigen Suchen

Bei wiederholter Verwendung von contains() in großen Datensätzen können die folgenden Techniken die Verarbeitungsgeschwindigkeit verbessern:

• Alle Zeichenketten im Voraus in Kleinbuchstaben umwandeln

Anstatt bei jedem Vergleich toLowerCase() aufzurufen, normalisieren Sie die Zeichenketten vorher:

List<String> normalizedList = originalList.stream()
    .map(String::toLowerCase)
    .collect(Collectors.toList());

• Verwenden Sie die Stream‑API mit parallel() für parallele Verarbeitung

Nutzen Sie CPU‑Kerne, um Suchvorgänge zu beschleunigen:

List<String> result = hugeTextList.parallelStream()
    .filter(line -> line.contains("keyword"))
    .collect(Collectors.toList());

• Verwenden Sie reguläre Ausdrücke für komplexe Suchmuster

Wenn die Bedingungen komplex sind und in einem einzigen Regex ausgedrückt werden können, kann Pattern besser performen:

Pattern pattern = Pattern.compile("error|fail|fatal");
for (String log : logs) {
    if (pattern.matcher(log).find()) {
        // matched
    }
}

6-3. Speicher‑Effizienz und Wiederverwendbarkeits‑Überlegungen

Operationen, die häufig Zeichenketten konvertieren – wie toLowerCase() oder substring() – können viele unnötige String‑Objekte erzeugen, was die Speichernutzung beeinflusst.
Dies ist besonders wichtig für langlaufende Anwendungen oder serverseitige Verarbeitung.

Wichtige Punkte:

• Vermeiden Sie das Erzeugen unnötiger String‑Instanzen.
• Bei großen Datensätzen sollten Sie Pufferung oder Chunk‑Verarbeitung in Betracht ziehen.
• Das Zwischenspeichern wiederholter contains()‑Ergebnisse kann die Leistung in bestimmten Fällen verbessern.

7. Vergleich mit anderen Programmiersprachen

Die contains()‑Methode von Java bietet eine einfache, zuverlässige Teilstring‑Übereinstimmung, aber andere Sprachen bieten ähnliche Funktionen mit eigenen Merkmalen.
Dieser Abschnitt vergleicht die Teilstring‑Prüfung in Python, JavaScript und C#, um Unterschiede und Gemeinsamkeiten hervorzuheben.

7-1. Python: Einfacher Teilstring‑Abgleich mit dem in‑Operator

In Python können Sie die Teilstring‑Einbeziehung mit dem in‑Operator prüfen:

text = "Hello, Python!"
if "Python" in text:
    print("含まれています")

Diese Syntax ist äußerst lesbar – fast wie natürliche Sprache – und erfordert nur minimalen Lernaufwand.

Unterschiede und Anmerkungen:

• in ist ein Sprachoperator, keine Methode.
• Python ist ebenfalls case‑sensitive bei Zeichenkettenvergleichen.
• None löst eine Ausnahme aus; Null‑Prüfungen sind erforderlich.

7-2. JavaScript: Teilstring‑Abgleich mit includes()

In JavaScript (ES6+) können Sie die includes()‑Methode verwenden:

const text = "JavaScript is fun";
console.log(text.includes("fun")); // true

Diese Methode ist Java’s contains() sehr ähnlich und lässt sich mental leicht übertragen.

Unterschiede und Anmerkungen:

• Das Übergeben von undefined löst keine Ausnahme aus; es gibt einfach false zurück.
• includes() funktioniert auch bei Arrays, was seine Vielseitigkeit erhöht.

7-3. C#: Contains() ähnlich wie Java

C# bietet ebenfalls eine Contains()‑Methode mit einem Verhalten, das Java ähnelt:

string text = "Welcome to C#";
bool result = text.Contains("C#");

Unterschiede und Anmerkungen:

• C# Contains() ist standardmäßig case‑sensitive, aber Sie können die Groß‑/Kleinschreibung mit StringComparison.OrdinalIgnoreCase ignorieren.
• Das Übergeben von null löst ArgumentNullException aus.

7-4. Vergleichstabelle über Sprachen hinweg

Zusammenfassung: Wählen Sie die passende Syntax für Ihren Anwendungsfall

Obwohl die Teilstring‑Prüfung eine häufige Anforderung in allen Sprachen ist, stellt jede Sprache ihre eigene Methode oder Syntax bereit.
Java’s contains() bietet Stabilität und Klarheit und ist daher gut geeignet für Unternehmenssysteme und wartbare Anwendungen.
Sprachen wie Python und JavaScript bieten eine einfachere und kompaktere Syntax, die ideal für leichte Skripte oder schnelles Prototyping sein kann.

Durch das Verständnis sowohl der gemeinsamen Konzepte als auch der spezifischen Eigenschaften jeder Sprache können Sie sichereren und effizienteren Code in verschiedenen Sprachen schreiben.

8. Häufig gestellte Fragen (FAQ)

Im Folgenden finden Sie häufig gestellte Fragen zur Java‑contains()‑Methode – sie helfen Ihnen, knifflige Punkte zu verstehen und häufige Fallstricke zu vermeiden.

Q1. Ist contains() case‑sensitive?

Ja, sie ist case‑sensitive.
Beispiel: "Java".contains("java") liefert false.

Lösung:

String input = "Welcome to Java";
boolean result = input.toLowerCase().contains("java");

Q2. Wie kann ich Teilstring‑Übereinstimmungen mit regulären Ausdrücken prüfen?

.contains() unterstützt keine regulären Ausdrücke.
Verwenden Sie matches() oder die Pattern‑Klasse stattdessen.

Beispiel (Überprüfung eines numerischen Musters):

import java.util.regex.Pattern;
import java.util.regex.Matcher;

String text = "注文番号: A123456";
Pattern pattern = Pattern.compile("A\\d+");
Matcher matcher = pattern.matcher(text);

if (matcher.find()) {
    System.out.println("パターンに一致しました。");
}

Q3. Was passiert, wenn ich contains() auf null aufrufe?

Eine NullPointerException wird ausgelöst.

String target = null;
System.out.println(target.contains("test")); // Error

Lösung:

if (target != null && target.contains("test")) {
    System.out.println("含まれています。");
}

Q4. Was passiert, wenn ich einen leeren String („“) an contains() übergebe?

Sie gibt immer true zurück.

String text = "Java";
System.out.println(text.contains("")); // true

Obwohl dies Teil der offiziellen Spezifikation ist, ist dieses Verhalten selten nützlich und kann unerwartete Fehler verursachen, wenn leere Strings nicht beabsichtigt sind.

Q5. Kann contains() mehrere Schlüsselwörter gleichzeitig suchen?

Nein. Jeder Aufruf prüft nur ein Schlüsselwort.

String text = "本日はシステムエラーが発生しました";
if (text.contains("エラー") || text.contains("障害") || text.contains("失敗")) {
    System.out.println("問題が検出されました。");
}

Dynamischer Ansatz:

List<String> keywords = Arrays.asList("エラー", "障害", "失敗");
boolean found = keywords.stream().anyMatch(text::contains);

Q6. Wann sollte ich contains() gegenüber indexOf() verwenden?

contains() gibt einen booleschen Wert zurück, während indexOf() einen numerischen Index zurückgibt.

• Verwenden Sie contains(), wenn Sie einfach wissen möchten, ob die Teilzeichenkette existiert.
• Verwenden Sie indexOf(), wenn Sie zusätzlich die Position benötigen.

  String text = "Error: Disk full";
  if (text.contains("Error")) {
      int pos = text.indexOf("Error");
      System.out.println("Position: " + pos);
  }
  

9. Fazit

Die contains()‑Methode von Java ist ein leistungsfähiges und praktisches Werkzeug, um zu bestimmen, ob ein bestimmter Teilstring in einem String enthalten ist.
Sie wird in vielen Szenarien eingesetzt, wie z. B. bei der Validierung von Benutzereingaben, der Protokollanalyse und der Datenfilterung.

In diesem Artikel haben wir behandelt:

• Grundlegende Syntax und Rückgabewerte
• Groß‑/Kleinschreibung und deren Handhabung
• Umgang mit null und leeren Strings
• Unterschiede zu anderen String‑Vergleichsmethoden
• Praktische Anwendungsfälle: Validierung, Protokollsuche, Stream‑Verarbeitung
• Leistungsaspekte und Optimierungstechniken
• Vergleich mit Python, JavaScript und C#
• Häufig gestellte Fragen und Fehlersuche

Obwohl contains() intuitiv und vielseitig ist, sollte seine Verwendung sorgfältig bewertet werden bei Fällen mit großen Datensätzen, häufigen Aufrufen oder komplexen Suchbedingungen.
Durch die Kombination von Normalisierung, Parallelverarbeitung, Regex und Caching‑Strategien können Sie sowohl Leistung als auch Lesbarkeit erhalten.

Da contains() grundlegend für die Arbeit mit Strings in Java ist, hoffen wir, dass Ihnen dieser Artikel hilft, es sicherer und effektiver in Ihren Entwicklungsprojekten zu nutzen.