Wie man prüft, ob ein String in Java eine bestimmte Teilzeichenfolge enthält

Einführung

In diesem Lab werden Sie lernen, wie Sie in Java prüfen können, ob ein String eine bestimmte Teilzeichenfolge enthält. Wir werden verschiedene Methoden für diese häufige Aufgabe untersuchen, beginnend mit der einfachen contains()-Methode. Sie werden lernen, wie Sie contains() verwenden, um festzustellen, ob ein String eine bestimmte Zeichenfolge enthält, und diese in einem einfachen Java-Programm implementieren.

Nach der Einführung in die contains()-Methode wird das Lab Sie durch die Verwendung der indexOf()-Methode führen, um nicht nur die Anwesenheit einer Teilzeichenfolge zu prüfen, sondern auch ihre Position innerhalb des Strings zu finden. Schließlich werden Sie Techniken lernen, um Groß- und Kleinschreibung bei der Prüfung von Teilzeichenfolgen zu ignorieren, damit Ihr Code auch Variationen in der Groß- und Kleinschreibung verarbeiten kann. Am Ende dieses Labs werden Sie verschiedene Ansätze zum Prüfen von Teilzeichenfolgen in Java gut verstanden haben.

Verwenden Sie contains() zur Suche nach einer Teilzeichenfolge

In diesem Schritt werden Sie lernen, wie Sie in Java prüfen können, ob ein String eine bestimmte Teilzeichenfolge enthält, indem Sie die contains()-Methode verwenden. Dies ist eine häufige Aufgabe in der Programmierung, beispielsweise wenn Sie nach einem Schlüsselwort in einem Satz suchen oder prüfen, ob ein Dateiname eine bestimmte Dateierweiterung enthält.

Die contains()-Methode ist Teil der String-Klasse in Java. Sie gibt true zurück, wenn der String die angegebene Zeichenfolge enthält, und false sonst.

Erstellen wir eine neue Java-Datei, um die Verwendung von contains() zu üben.

Öffnen Sie den Dateiexplorer auf der linken Seite der WebIDE.
Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Klicken Sie mit der rechten Maustaste in den leeren Bereich und wählen Sie "Neue Datei".
Benennen Sie die neue Datei StringContains.java.
Öffnen Sie die Datei StringContains.java im Editor.

Kopieren und fügen Sie den folgenden Code in den Editor ein:

public class StringContains {
    public static void main(String[] args) {
        String sentence = "Java programming is fun and powerful.";
        String keyword = "programming";

        // Check if the sentence contains the keyword
        boolean containsKeyword = sentence.contains(keyword);

        System.out.println("Sentence: \"" + sentence + "\"");
        System.out.println("Keyword: \"" + keyword + "\"");
        System.out.println("Does the sentence contain the keyword? " + containsKeyword);

        String anotherKeyword = "Python";
        boolean containsAnotherKeyword = sentence.contains(anotherKeyword);

        System.out.println("\nAnother keyword: \"" + anotherKeyword + "\"");
        System.out.println("Does the sentence contain the another keyword? " + containsAnotherKeyword);
    }
}

In diesem Code:

Wir deklarieren eine String-Variable sentence und eine String-Variable keyword.
Wir verwenden sentence.contains(keyword), um zu prüfen, ob sentence die Zeichenfolge in keyword enthält. Das Ergebnis wird in einer boolean-Variable containsKeyword gespeichert.
Wir geben den ursprünglichen Satz, das Schlüsselwort und das Ergebnis der contains()-Prüfung aus.
Wir wiederholen den Vorgang mit einem anderen Schlüsselwort, "Python", um das Ergebnis zu sehen, wenn die Teilzeichenfolge nicht gefunden wird.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Öffnen Sie das Terminal unten in der WebIDE.
Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden, indem Sie den folgenden Befehl verwenden:
```
cd ~/project
```
Kompilieren Sie das Java-Programm mit dem javac-Befehl:
```
javac StringContains.java
```
Wenn keine Fehler auftreten, sehen Sie keine Ausgabe. Es wird eine StringContains.class-Datei im Verzeichnis ~/project erstellt.

Führen Sie das kompilierte Java-Programm mit dem java-Befehl aus:

java StringContains

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Sentence: "Java programming is fun and powerful."
Keyword: "programming"
Does the sentence contain the keyword? true

Another keyword: "Python"
Does the sentence contain the another keyword? false

Diese Ausgabe zeigt, dass die contains()-Methode korrekt erkannt hat, dass der Satz "programming" enthält, aber nicht "Python".

Entdecken Sie indexOf() zur Bestimmung der Position einer Teilzeichenfolge

Im vorherigen Schritt haben wir gelernt, wie man mit contains() prüft, ob ein String eine Teilzeichenfolge enthält. Jetzt wollen wir uns eine weitere nützliche Methode, indexOf(), anschauen. Diese Methode sagt uns nicht nur, ob eine Teilzeichenfolge existiert, sondern gibt uns auch ihre Startposition innerhalb des Strings an.

Die indexOf()-Methode in der String-Klasse von Java gibt den Index der ersten Vorkommens der angegebenen Teilzeichenfolge innerhalb des Strings zurück. Der Index ist die Position des ersten Zeichens der Teilzeichenfolge. Denken Sie daran, dass in der Programmierung die Indizierung normalerweise bei 0 beginnt. Wenn die Teilzeichenfolge nicht gefunden wird, gibt indexOf() -1 zurück.

Lassen Sie uns die vorherige Java-Datei StringContains.java ändern, um die indexOf()-Methode zu verwenden.

Öffnen Sie die Datei StringContains.java im WebIDE-Editor.

Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:

public class StringContains {
    public static void main(String[] args) {
        String sentence = "Java programming is fun and powerful.";
        String keyword = "programming";

        // Find the index of the keyword
        int index = sentence.indexOf(keyword);

        System.out.println("Sentence: \"" + sentence + "\"");
        System.out.println("Keyword: \"" + keyword + "\"");

        if (index != -1) {
            System.out.println("The keyword \"" + keyword + "\" was found at index: " + index);
        } else {
            System.out.println("The keyword \"" + keyword + "\" was not found.");
        }

        String anotherKeyword = "Python";
        int anotherIndex = sentence.indexOf(anotherKeyword);

        System.out.println("\nAnother keyword: \"" + anotherKeyword + "\"");

        if (anotherIndex != -1) {
            System.out.println("The keyword \"" + anotherKeyword + "\" was found at index: " + anotherIndex);
        } else {
            System.out.println("The keyword \"" + anotherKeyword + "\" was not found.");
        }
    }
}

In diesem aktualisierten Code:

Wir verwenden sentence.indexOf(keyword), um den Startindex des keyword innerhalb des sentence zu finden. Das Ergebnis wird in einer int-Variable index gespeichert.
Wir verwenden eine if-Anweisung, um zu prüfen, ob der zurückgegebene index -1 ist. Wenn er nicht -1 ist, bedeutet das, dass das Schlüsselwort gefunden wurde, und wir geben seinen Index aus. Andernfalls geben wir eine Nachricht aus, die angibt, dass das Schlüsselwort nicht gefunden wurde.
Wir wiederholen den Vorgang für "Python", um den Fall zu demonstrieren, in dem die Teilzeichenfolge nicht vorhanden ist.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Öffnen Sie das Terminal unten in der WebIDE.
Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie das geänderte Java-Programm:
```
javac StringContains.java
```

Führen Sie das kompilierte Java-Programm aus:

java StringContains

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Sentence: "Java programming is fun and powerful."
Keyword: "programming"
The keyword "programming" was found at index: 5

Another keyword: "Python"
The keyword "Python" was not found.

Die Ausgabe zeigt, dass "programming" an Index 5 im Satz beginnt (denken Sie daran, dass 'J' an Index 0, 'a' an Index 1 und so weiter steht, einschließlich des Leerzeichens). Sie zeigt auch korrekt an, dass "Python" nicht gefunden wurde.

Die Verwendung von indexOf() ist eine leistungsstarke Methode, um nicht nur die Anwesenheit einer Teilzeichenfolge zu prüfen, sondern auch ihre genaue Position zu bestimmen, was für verschiedene Zeichenkettenmanipulationstasks nützlich sein kann.

Stellen Sie eine gross- und kleinschreibungsunabhängige Teilzeichenfolgenprüfung her

In den vorherigen Schritten haben wir contains() und indexOf() verwendet, um nach Teilzeichenfolgen zu suchen. Allerdings sind diese Methoden case-sensitive (berücksichtigen die Groß- und Kleinschreibung). Das bedeutet, dass "Java" als unterschiedlich von "java" oder "JAVA" angesehen wird. In vielen Situationen möchten Sie möglicherweise eine Suche ohne Berücksichtigung der Groß- und Kleinschreibung durchführen.

Die String-Klasse in Java hat keine integrierte Methode wie containsIgnoreCase() oder indexOfIgnoreCase(). Wir können jedoch die Groß- und Kleinschreibung ignorieren, indem wir sowohl den ursprünglichen String als auch die Teilzeichenfolge in dasselbe Format (entweder Kleinbuchstaben oder Großbuchstaben) umwandeln, bevor wir die Suche durchführen. Der gebräuchlichste Ansatz besteht darin, beide mit der toLowerCase()-Methode in Kleinbuchstaben umzuwandeln.

Lassen Sie uns die Datei StringContains.java erneut ändern, um eine Suche ohne Berücksichtigung der Groß- und Kleinschreibung durchzuführen.

Öffnen Sie die Datei StringContains.java im WebIDE-Editor.

Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:

public class StringContains {
    public static void main(String[] args) {
        String sentence = "Java programming is fun and powerful.";
        String keyword = "JAVA"; // Using uppercase for demonstration

        // Convert both strings to lowercase for case-insensitive comparison
        String lowerSentence = sentence.toLowerCase();
        String lowerKeyword = keyword.toLowerCase();

        // Use contains() on the lowercase strings
        boolean containsKeyword = lowerSentence.contains(lowerKeyword);

        System.out.println("Original Sentence: \"" + sentence + "\"");
        System.out.println("Original Keyword: \"" + keyword + "\"");
        System.out.println("Does the sentence contain the keyword (case-insensitive)? " + containsKeyword);

        // You can also use indexOf() in a case-insensitive way
        int index = lowerSentence.indexOf(lowerKeyword);

        if (index != -1) {
            System.out.println("The keyword \"" + keyword + "\" was found at index (case-insensitive): " + index);
        } else {
            System.out.println("The keyword \"" + keyword + "\" was not found (case-insensitive).");
        }
    }
}

In diesem Code:

Wir definieren das keyword als "JAVA" (Großbuchstaben).
Wir erstellen neue Strings lowerSentence und lowerKeyword, indem wir die ursprünglichen Strings mit toLowerCase() in Kleinbuchstaben umwandeln.
Wir verwenden dann die contains()-Methode auf den Strings in Kleinbuchstaben, um eine Prüfung ohne Berücksichtigung der Groß- und Kleinschreibung durchzuführen.
Wir zeigen auch, wie man indexOf() auf die Strings in Kleinbuchstaben anwendet, um eine Suche ohne Berücksichtigung der Groß- und Kleinschreibung durchzuführen.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Öffnen Sie das Terminal unten in der WebIDE.
Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie das geänderte Java-Programm:
```
javac StringContains.java
```

Führen Sie das kompilierte Java-Programm aus:

java StringContains

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Original Sentence: "Java programming is fun and powerful."
Original Keyword: "JAVA"
Does the sentence contain the keyword (case-insensitive)? true
The keyword "JAVA" was found at index (case-insensitive): 0

Diese Ausgabe zeigt, dass auch wenn das ursprüngliche Schlüsselwort "JAVA" (Großbuchstaben) war, die Suche ohne Berücksichtigung der Groß- und Kleinschreibung es korrekt im Satz gefunden und seinen Index gemeldet hat (der für "Java" in Kleinbuchstaben 0 ist).

Indem Sie Strings in ein einheitliches Format umwandeln, bevor Sie suchen, können Sie in Java problemlos Teilzeichenfolgesuchen ohne Berücksichtigung der Groß- und Kleinschreibung durchführen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob ein String eine bestimmte Teilzeichenfolge enthält. Wir haben zunächst die contains()-Methode verwendet, die eine einfache boolesche Prüfung für die Anwesenheit einer Teilzeichenfolge bietet. Diese Methode ist unkompliziert und nützlich für grundlegende Prüfungen, ob eine Teilzeichenfolge vorhanden ist.

Anschließend haben wir uns die indexOf()-Methode angeschaut, die nicht nur prüft, ob eine Teilzeichenfolge vorhanden ist, sondern auch den Startindex des ersten Vorkommens zurückgibt. Dies ermöglicht eine detailliertere Analyse der Position der Teilzeichenfolge innerhalb des Strings. Schließlich haben wir die häufige Anforderung behandelt, Teilzeichenfolgesuchen ohne Berücksichtigung der Groß- und Kleinschreibung durchzuführen, und Techniken gezeigt, wie man dies unabhängig von der Groß- und Kleinschreibung des ursprünglichen Strings erreichen kann.