Compter les occurrences d'un caractère

Introduction

En Java, il est facile de compter le nombre de fois qu'un caractère spécifique apparaît dans une chaîne de caractères. Ce laboratoire vous guidera à travers différentes méthodes que vous pouvez utiliser pour compter les occurrences d'un caractère dans une chaîne.

Skills Graph

Approche itérative

Nous pouvons utiliser une approche itérative pour parcourir chaque caractère d'une chaîne de caractères afin de compter le nombre de fois qu'un caractère spécifique apparaît.

Créez un fichier Java nommé CountOccurrences.java dans le répertoire ~/project, puis copiez le contenu suivant dans le fichier :

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);
    }

}

Pour compiler et exécuter le programme, exécutez les commandes suivantes dans le terminal :

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

La sortie devrait être :

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

Approche récursive

Nous pouvons également utiliser une approche récursive pour compter les occurrences d'un caractère dans une chaîne de caractères. Cela implique d'utiliser deux méthodes, la première étant récursive et la seconde invoquant la première.

Copiez et collez le bloc de code suivant après le bloc de code de l'Étape 1 dans le fichier 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);
}

Pour compiler et exécuter le programme mis à jour, exécutez les mêmes commandes que dans l'Étape 1 :

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

Utilisation des flux Java 8

Nous pouvons utiliser les flux Java 8 pour compter les occurrences d'un caractère dans une chaîne de caractères.

Copiez et collez le bloc de code suivant après le bloc de code de l'Étape 2 dans le fichier 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);
}

Pour utiliser la méthode des flux Java 8, ajoutez la ligne de code suivante à la méthode main après le bloc de code de l'Étape 2 :

usingStreams(s);

Pour compiler et exécuter le programme mis à jour, exécutez les mêmes commandes que dans l'Étape 1 :

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

Utilisation de bibliothèques externes

Nous pouvons utiliser des bibliothèques externes pour compter les occurrences d'un caractère dans une chaîne de caractères.

Utilisation de la bibliothèque Guava

La bibliothèque Guava fournit la classe CharMatcher qui peut compter le nombre d'occurrences d'un caractère donné.

Ajoutez le bloc de code suivant après le bloc de code de l'Étape 3 :

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;
}

Pour utiliser la bibliothèque Guava, ajoutez les importations suivantes en haut du fichier CountOccurrences.java :

import com.google.common.base.CharMatcher;

Dans la méthode main, appelez la méthode usingGuava avec le paramètre de chaîne :

usingGuava(s);

Pour compiler et exécuter le programme mis à jour, exécutez les mêmes commandes que dans l'Étape 1 :

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

Utilisation de la bibliothèque Apache

La bibliothèque Apache Commons fournit une classe StringUtils qui a une méthode pratique countMatches() qui prend un caractère et une chaîne en entrée et renvoie le nombre d'occurrences de ce caractère dans cette chaîne en sortie.

Ajoutez le bloc de code suivant après le bloc de code de l'Étape 4 :

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;
}

Pour utiliser la bibliothèque Apache Commons, ajoutez l'importation suivante en haut du fichier CountOccurrences.java :

import org.apache.commons.lang3.StringUtils;

Dans la méthode main, appelez la méthode usingApache avec le paramètre de chaîne :

usingApache(s);

Pour compiler et exécuter le programme mis à jour, exécutez les mêmes commandes que dans l'Étape 1, avec un classpath supplémentaire :

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

Sommaire

Dans ce laboratoire, nous avons couvert les étapes suivantes :

1. Approche itérative - parcourir chaque caractère pour compter les occurrences d'un caractère.
2. Approche récursive - utiliser la récursion pour compter les occurrences d'un caractère.
3. Flux Java 8 - utiliser les flux pour compter les occurrences d'un caractère.
4. Bibliothèques externes - utiliser les bibliothèques Guava et Apache pour compter les occurrences d'un caractère.

Après avoir terminé ce laboratoire, vous devriez avoir une meilleure compréhension des différentes méthodes pour compter les occurrences d'un caractère dans une chaîne de caractères.