Zählen der Vorkommen eines Zeichens

Einführung

In Java können wir leicht die Anzahl der Vorkommen eines bestimmten Zeichens in einem String zählen. In diesem Lab werden wir Ihnen verschiedene Methoden zeigen, mit denen Sie die Vorkommen eines Zeichens in einem String zählen können.

Iterativer Ansatz

Wir können einen iterativen Ansatz verwenden, um jeden Charakter in einem String zu durchlaufen und die Anzahl der Vorkommen eines bestimmten Zeichens zu zählen.

Erstellen Sie in das Verzeichnis ~/project eine Java-Datei namens CountOccurrences.java und kopieren Sie den folgenden Inhalt in die Datei:

public class CountOccurrences {

    public static int countChars(String str, char c) {
        int count = 0;

        for(int i = 0; i < str.length(); i++) {
            char currChar = str.charAt(i);
            if(currChar == c)
                count += 1;
        }

        return count;
    }

    public static void main(String[] args) {
        String s = "Java is an awesome language!";
        int charCountOfA = countChars(s, 'a');
        int charCountOfG = countChars(s, 'g');
        int charCountOfE = countChars(s, 'e');

        System.out.println("The String is: " + s);
        System.out.println("Character count of 'a': " + charCountOfA);
        System.out.println("Character count of 'g': " + charCountOfG);
        System.out.println("Character count of 'e': " + charCountOfE);
    }

}

Um das Programm zu kompilieren und auszuführen, führen Sie in der Konsole die folgenden Befehle aus:

cd ~/project
javac CountOccurrences.java && java CountOccurrences

Die Ausgabe sollte wie folgt sein:

The String is: Java is an awesome language!
Character count of 'a': 6
Character count of 'g': 2
Character count of 'e': 3

Rekursiver Ansatz

Wir können auch einen rekursiven Ansatz verwenden, um die Vorkommen eines Zeichens in einem String zu zählen. Dies erfordert die Verwendung von zwei Methoden, wobei die erste rekursiv ist und die zweite die erste aufruft.

Kopieren Sie den folgenden Codeblock nach dem Codeblock aus Schritt 1 in die Datei CountOccurrences.java:

public static int countCharsRecur(String str, char c, int idx) {
    if(idx >= str.length())
        return 0;
    else {
        int count = 0;
        if(str.charAt(idx) == c)
            count = 1;
        return count + countCharsRecur(str, c, idx + 1);
    }
}

public static int countChars(String s, char c) {
    return countCharsRecur(s, c, 0);
}

Um das aktualisierte Programm zu kompilieren und auszuführen, führen Sie die gleichen Befehle wie in Schritt 1 aus:

cd ~/project
javac CountOccurrences.java && java CountOccurrences

Verwenden von Java 8 Streams

Wir können Java 8 Streams verwenden, um die Vorkommen eines Zeichens in einem String zu zählen.

Kopieren Sie den folgenden Codeblock nach dem Codeblock aus Schritt 2 in die Datei CountOccurrences.java:

public static void usingStreams(String s) {
    int charCountOfA = (int) s.chars().filter(c -> c == 'a').count();
    int charCountOfG = (int) s.chars().filter(c -> c == 'g').count();
    int charCountOfE = (int) s.chars().filter(c -> c == 'e').count();

    System.out.println("The String is: " + s);
    System.out.println("Character count of 'a': " + charCountOfA);
    System.out.println("Character count of 'g': " + charCountOfG);
    System.out.println("Character count of 'e': " + charCountOfE);
}

Um die Java 8 Streams-Methode zu verwenden, fügen Sie die folgende Codezeile in die main-Methode nach dem Codeblock aus Schritt 2 hinzu:

usingStreams(s);

Um das aktualisierte Programm zu kompilieren und auszuführen, führen Sie die gleichen Befehle wie in Schritt 1 aus:

cd ~/project
javac CountOccurrences.java && java CountOccurrences

Verwenden externer Bibliotheken

Wir können externe Bibliotheken verwenden, um die Vorkommen eines Zeichens in einem String zu zählen.

Verwenden der Guava-Bibliothek

Die Guava-Bibliothek bietet die Klasse CharMatcher, mit der die Anzahl der Vorkommen eines angegebenen Zeichens gezählt werden kann.

Fügen Sie den folgenden Codeblock nach dem Codeblock aus Schritt 3 hinzu:

public static int usingGuava(String str) {
    CharMatcher cm = CharMatcher.is('a');
    int charCountOfA = cm.countIn(str);

    System.out.println("Character count of 'a': " + charCountOfA);
    return charCountOfA;
}

Um die Guava-Bibliothek zu verwenden, fügen Sie die folgenden Imports am Anfang der Datei CountOccurrences.java hinzu:

import com.google.common.base.CharMatcher;

In der main-Methode rufen Sie die usingGuava-Methode mit dem String-Parameter auf:

usingGuava(s);

Um das aktualisierte Programm zu kompilieren und auszuführen, führen Sie die gleichen Befehle wie in Schritt 1 aus:

cd ~/project
javac -cp ".:./lib/*" CountOccurrences.java && java -cp ".:./lib/*" CountOccurrences

Verwenden der Apache-Bibliothek

Die Apache Commons-Bibliothek bietet eine Klasse StringUtils mit einer bequemen Methode countMatches(), die ein Zeichen und einen String als Eingabe nimmt und die Anzahl des Zeichens in dem String als Ausgabe zurückgibt.

Fügen Sie den folgenden Codeblock nach dem Codeblock aus Schritt 4 hinzu:

public static int usingApache(String str) {
    int charCountOfA = StringUtils.countMatches(str, 'a');
    int charCountOfG = StringUtils.countMatches(str, 'g');
    int charCountOfE = StringUtils.countMatches(str, 'e');

    System.out.println("Character count of 'a': " + charCountOfA);
    System.out.println("Character count of 'g': " + charCountOfG);
    System.out.println("Character count of 'e': " + charCountOfE);

    return charCountOfA;
}

Um die Apache Commons-Bibliothek zu verwenden, fügen Sie den folgenden Import am Anfang der Datei CountOccurrences.java hinzu:

import org.apache.commons.lang3.StringUtils;

In der main-Methode rufen Sie die usingApache-Methode mit dem String-Parameter auf:

usingApache(s);

Um das aktualisierte Programm zu kompilieren und auszuführen, führen Sie die gleichen Befehle wie in Schritt 1 aus, mit einem zusätzlichen Classpath:

cd ~/project
javac -cp ".:./lib/*" CountOccurrences.java && java -cp ".:./lib/*" CountOccurrences

Zusammenfassung

In diesem Lab haben wir die folgenden Schritte behandelt:

1. Iterativer Ansatz - Durchlaufen Sie jeden Charakter, um die Vorkommen eines Zeichens zu zählen.
2. Rekursiver Ansatz - Verwenden Sie die Rekursion, um die Vorkommen eines Zeichens zu zählen.
3. Java 8 Streams - Verwenden Sie Streams, um die Vorkommen eines Zeichens zu zählen.
4. Externe Bibliotheken - Verwenden Sie die Guava- und Apache-Bibliotheken, um die Vorkommen eines Zeichens zu zählen.

Nach Abschluss dieses Labs sollten Sie ein besseres Verständnis der verschiedenen Methoden haben, um die Vorkommen eines Zeichens in einem String zu zählen.