Wie man prüft, ob ein String in Java mit einem bestimmten Suffix endet

Einführung

In diesem Lab lernen Sie, wie Sie in Java prüfen können, ob ein String mit einem bestimmten Suffix endet. Dies ist eine grundlegende Fähigkeit für Aufgaben wie die Validierung von Dateitypen oder die Analyse von Daten anhand ihrer Endung. Sie werden die Methode endsWith() untersuchen, ihre Groß- und Kleinschreibungsempfindlichkeit verstehen und lernen, wie Sie sie mit startsWith() kombinieren können, um komplexere Prüfungen durchzuführen. Anhand von praktischen Beispielen werden Sie praktische Erfahrungen in der Anwendung dieser Zeichenkettenmanipulationstechniken in Ihren Java-Programmen sammeln.

Skills Graph

Verwendung von endsWith() zur Überprüfung des Suffixes

In diesem Schritt werden wir untersuchen, wie man die Methode endsWith() in Java verwendet, um zu prüfen, ob ein String mit einem bestimmten Suffix endet. Dies ist eine häufige Aufgabe, wenn Sie Dateierweiterungen validieren, nach bestimmten Mustern suchen oder Daten anhand ihrer Endung verarbeiten müssen.

Die Methode endsWith() ist Teil der String-Klasse in Java. Sie nimmt ein einzelnes Argument entgegen, nämlich das Suffix, nach dem Sie suchen möchten, und gibt einen booleschen Wert zurück: true, wenn der String mit dem angegebenen Suffix endet, und false sonst.

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu demonstrieren, wie endsWith() funktioniert.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor. Wenn Sie sie nicht geöffnet haben, können Sie sie im Dateiexplorer auf der linken Seite im Ordner project finden.

2. Ersetzen Sie den vorhandenen Code in HelloJava.java durch folgenden Code:

   public class HelloJava {
       public static void main(String[] args) {
           String fileName = "document.txt";
           boolean endsWithTxt = fileName.endsWith(".txt");
   
           System.out.println("Does '" + fileName + "' end with '.txt'? " + endsWithTxt);
   
           String imageUrl = "photo.jpg";
           boolean endsWithJpg = imageUrl.endsWith(".jpg");
   
           System.out.println("Does '" + imageUrl + "' end with '.jpg'? " + endsWithJpg);
   
           String documentName = "report.pdf";
           boolean endsWithDoc = documentName.endsWith(".doc");
   
           System.out.println("Does '" + documentName + "' end with '.doc'? " + endsWithDoc);
       }
   }

   In diesem Code:

   • Wir deklarieren drei String-Variablen: fileName, imageUrl und documentName.
   • Wir verwenden die Methode endsWith() für jeden String, um zu prüfen, ob er mit einem bestimmten Suffix endet (.txt, .jpg, .doc).
   • Die Ergebnisse (true oder false) werden in booleschen Variablen (endsWithTxt, endsWithJpg, endsWithDoc) gespeichert.
   • Schließlich geben wir die Ergebnisse in der Konsole aus, indem wir System.out.println() verwenden.

3. Speichern Sie die Datei HelloJava.java (Strg+S oder Cmd+S).

4. Jetzt lassen Sie uns das Programm kompilieren. Öffnen Sie die Terminal-Konsole unten im WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Führen Sie dann den folgenden Befehl aus:

   javac HelloJava.java

   Wenn keine Fehler auftreten, wird die Kompilierung ohne Meldung abgeschlossen, und es wird eine Datei HelloJava.class im Verzeichnis ~/project erstellt.

5. Führen Sie schließlich das kompilierte Programm mit dem Befehl java aus:

   java HelloJava

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Does 'document.txt' end with '.txt'? true
   Does 'photo.jpg' end with '.jpg'? true
   Does 'report.pdf' end with '.doc'? false

   Diese Ausgabe zeigt die Ergebnisse unserer endsWith()-Prüfungen und bestätigt, dass document.txt mit .txt endet, photo.jpg mit .jpg endet und report.pdf nicht mit .doc endet.

Sie haben erfolgreich die Methode endsWith() verwendet, um String-Suffixe zu prüfen. Dies ist eine grundlegende Operation, die Sie häufig in der Java-Programmierung verwenden werden.

Testen von Suffixen mit Berücksichtigung der Groß- und Kleinschreibung

Im vorherigen Schritt haben wir gelernt, wie man die Methode endsWith() verwendet. Es ist wichtig zu verstehen, dass die endsWith()-Methode in Java eine größenempfindliche (case-sensitive) Vergleichsmethode ist. Das bedeutet, dass "file.txt" mit ".txt" endet, aber nicht mit ".TXT".

Lassen Sie uns unser Programm ändern, um diese Groß- und Kleinschreibungsempfindlichkeit in Aktion zu sehen.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

2. Ersetzen Sie den vorhandenen Code durch folgenden Code:

   public class HelloJava {
       public static void main(String[] args) {
           String fileName = "document.txt";
   
           // Case-sensitive check
           boolean endsWithLowercaseTxt = fileName.endsWith(".txt");
           System.out.println("Does '" + fileName + "' end with '.txt' (lowercase)? " + endsWithLowercaseTxt);
   
           // Case-sensitive check with uppercase suffix
           boolean endsWithUppercaseTxt = fileName.endsWith(".TXT");
           System.out.println("Does '" + fileName + "' end with '.TXT' (uppercase)? " + endsWithUppercaseTxt);
   
           String anotherFile = "IMAGE.JPG";
   
           // Case-sensitive check with lowercase suffix
           boolean endsWithLowercaseJpg = anotherFile.endsWith(".jpg");
           System.out.println("Does '" + anotherFile + "' end with '.jpg' (lowercase)? " + endsWithLowercaseJpg);
   
           // Case-sensitive check with uppercase suffix
           boolean endsWithUppercaseJpg = anotherFile.endsWith(".JPG");
           System.out.println("Does '" + anotherFile + "' end with '.JPG' (uppercase)? " + endsWithUppercaseJpg);
       }
   }

   In diesem aktualisierten Code testen wir explizit die endsWith()-Methode sowohl mit Klein- als auch mit Großbuchstaben-Suffixen, um die Groß- und Kleinschreibungsempfindlichkeit der Methode zu verdeutlichen.

3. Speichern Sie die Datei HelloJava.java.

4. Kompilieren Sie das geänderte Programm in der Terminal-Konsole:

   javac HelloJava.java

5. Führen Sie das kompilierte Programm aus:

   java HelloJava

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Does 'document.txt' end with '.txt' (lowercase)? true
   Does 'document.txt' end with '.TXT' (uppercase)? false
   Does 'IMAGE.JPG' end with '.jpg' (lowercase)? false
   Does 'IMAGE.JPG' end with '.JPG' (uppercase)? true

   Wie Sie sehen können, hat die endsWith()-Methode false zurückgegeben, wenn die Groß- und Kleinschreibung des Suffixes nicht exakt mit der im String übereinstimmte.

Wenn Sie eine größenunempfindliche (case-insensitive) Prüfung durchführen müssen, würden Sie normalerweise sowohl den String als auch das Suffix in die gleiche Groß- oder Kleinschreibung umwandeln, bevor Sie endsWith() verwenden. Wir werden das in diesem speziellen Schritt nicht behandeln, aber es ist eine nützliche Technik, die Sie im Hinterkopf behalten sollten.

Das Verständnis der Groß- und Kleinschreibungsempfindlichkeit ist von entscheidender Bedeutung, wenn Sie mit Strings in Java arbeiten, da viele String-Methoden standardmäßig größenempfindlich sind.

Kombination von startsWith()- und endsWith()-Prüfungen

Neben der Prüfung des Endes eines Strings mit endsWith() können Sie auch den Anfang eines Strings mithilfe der Methode startsWith() prüfen. Diese Methode funktioniert ähnlich wie endsWith(). Sie nimmt ein Präfix als Argument entgegen und gibt true zurück, wenn der String mit diesem Präfix beginnt, und false sonst. Wie endsWith() ist auch startsWith() größenempfindlich (case-sensitive).

Das Kombinieren von startsWith() und endsWith() ermöglicht es Ihnen, genauere Prüfungen an Strings durchzuführen. Beispielsweise möchten Sie möglicherweise prüfen, ob ein Dateiname mit "temp_" beginnt und mit ".log" endet.

Lassen Sie uns unser Programm aktualisieren, um sowohl startsWith() als auch endsWith() zu verwenden.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

2. Ersetzen Sie den vorhandenen Code durch folgenden Code:

   public class HelloJava {
       public static void main(String[] args) {
           String logFileName = "temp_application_error.log";
   
           boolean startsWithTemp = logFileName.startsWith("temp_");
           boolean endsWithLog = logFileName.endsWith(".log");
   
           System.out.println("Does '" + logFileName + "' start with 'temp_'? " + startsWithTemp);
           System.out.println("Does '" + logFileName + "' end with '.log'? " + endsWithLog);
   
           // Combine checks using the logical AND operator (&&)
           boolean isTempLogFile = startsWithTemp && endsWithLog;
           System.out.println("Is '" + logFileName + "' a temporary log file? " + isTempLogFile);
   
           String anotherFile = "data_report.txt";
   
           boolean startsWithData = anotherFile.startsWith("data_");
           boolean endsWithTxt = anotherFile.endsWith(".txt");
   
           System.out.println("Does '" + anotherFile + "' start with 'data_'? " + startsWithData);
           System.out.println("Does '" + anotherFile + "' end with '.txt'? " + endsWithTxt);
   
           boolean isDataTxtFile = startsWithData && endsWithTxt;
           System.out.println("Is '" + anotherFile + "' a data text file? " + isDataTxtFile);
       }
   }

   In diesem Code:

   • Wir verwenden die Methode startsWith(), um den Anfang der Strings zu prüfen.
   • Wir nutzen den logischen UND-Operator (&&), um die Ergebnisse von startsWith() und endsWith() zu kombinieren. Der &&-Operator gibt nur dann true zurück, wenn beide Bedingungen true sind.

3. Speichern Sie die Datei HelloJava.java.

4. Kompilieren Sie das Programm in der Terminal-Konsole:

   javac HelloJava.java

5. Führen Sie das kompilierte Programm aus:

   java HelloJava

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Does 'temp_application_error.log' start with 'temp_'? true
   Does 'temp_application_error.log' end with '.log'? true
   Is 'temp_application_error.log' a temporary log file? true
   Does 'data_report.txt' start with 'data_'? true
   Does 'data_report.txt' end with '.txt'? true
   Is 'data_report.txt' a data text file? true

   Diese Ausgabe zeigt, wie Sie startsWith() und endsWith() zusammen mit logischen Operatoren verwenden können, um komplexere String-Prüfungen durchzuführen.

Sie haben nun gelernt, wie Sie sowohl startsWith() als auch endsWith() verwenden und diese kombinieren können, um sowohl den Anfang als auch das Ende eines Strings zu überprüfen. Diese Methoden sind grundlegende Werkzeuge für die String-Manipulation und -Validierung in Java.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob ein String mit einem bestimmten Suffix endet, indem man die Methode endsWith() verwendet. Wir haben ihre grundlegende Verwendung untersucht, um Suffixe wie Dateierweiterungen zu überprüfen, und beobachtet, wie sie einen booleschen Wert zurückgibt, der angibt, ob der String mit dem angegebenen Suffix endet.

Wir haben auch die Groß- und Kleinschreibungsempfindlichkeit (case sensitivity) der Methode endsWith() untersucht und gelernt, wie man größenunempfindliche (case-insensitive) Prüfungen durchführt, indem man den String und das Suffix vor dem Vergleich in die gleiche Groß- oder Kleinschreibung umwandelt. Schließlich haben wir die Methoden startsWith() und endsWith() kombiniert, um zu prüfen, ob ein String sowohl mit bestimmten Präfixen beginnt als auch mit bestimmten Suffixen endet. Dies zeigt, wie diese Methoden zusammen für komplexere String-Validierungen verwendet werden können.