Contar Ocorrências de um Caractere

Introdução

Em Java, podemos facilmente contar o número de vezes que um caractere específico ocorre em uma string. Este laboratório irá guiá-lo através de diferentes métodos que você pode usar para contar as ocorrências de um caractere em uma string.

Abordagem Iterativa

Podemos usar uma abordagem iterativa para percorrer cada caractere em uma string para contar o número de vezes que um caractere específico ocorre.

Crie um arquivo Java chamado CountOccurrences.java no diretório ~/project e copie o seguinte conteúdo para o arquivo:

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

}

Para compilar e executar o programa, execute os seguintes comandos no terminal:

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

A saída deve ser:

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

Abordagem Recursiva

Também podemos usar uma abordagem recursiva para contar as ocorrências de um caractere em uma string. Isso envolve o uso de dois métodos, sendo o primeiro recursivo e o segundo invocando o primeiro.

Copie e cole o seguinte bloco de código após o bloco de código do Passo 1 no arquivo 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);
}

Para compilar e executar o programa atualizado, execute os mesmos comandos do Passo 1:

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

Usando Streams do Java 8

Podemos usar Java 8 Streams para contar as ocorrências de um caractere em uma string.

Copie e cole o seguinte bloco de código após o bloco de código do Passo 2 no arquivo 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);
}

Para usar o método Java 8 Streams, adicione a seguinte linha de código ao método main após o bloco de código do Passo 2:

usingStreams(s);

Para compilar e executar o programa atualizado, execute os mesmos comandos do Passo 1:

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

Utilizando Bibliotecas Externas

Podemos usar bibliotecas externas para contar as ocorrências de um caractere em uma string.

Usando a Biblioteca Guava

A biblioteca Guava fornece a classe CharMatcher que pode contar o número de ocorrências de um determinado caractere.

Adicione o seguinte bloco de código após o bloco de código do Passo 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;
}

Para usar a biblioteca Guava, adicione as seguintes importações ao topo do arquivo CountOccurrences.java:

import com.google.common.base.CharMatcher;

No método main, chame o método usingGuava com o parâmetro string:

usingGuava(s);

Para compilar e executar o programa atualizado, execute os mesmos comandos do Passo 1:

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

Usando a Biblioteca Apache

A biblioteca Apache Commons fornece uma classe StringUtils que possui um método countMatches() conveniente que recebe um char e uma string como entrada e retorna a contagem do caractere nessa String como saída.

Adicione o seguinte bloco de código após o bloco de código do Passo 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;
}

Para usar a biblioteca Apache Commons, adicione a seguinte importação ao topo do arquivo CountOccurrences.java:

import org.apache.commons.lang3.StringUtils;

No método main, chame o método usingApache com o parâmetro string:

usingApache(s);

Para compilar e executar o programa atualizado, execute os mesmos comandos do Passo 1, com um classpath adicional:

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

Resumo

Neste laboratório, cobrimos os seguintes passos:

1. Abordagem Iterativa - percorrer cada caractere para contar as ocorrências de um caractere.
2. Abordagem Recursiva - usar recursão para contar as ocorrências de um caractere.
3. Java 8 Streams - usar Streams para contar as ocorrências de um caractere.
4. Bibliotecas Externas - usar as bibliotecas Guava e Apache para contar as ocorrências de um caractere.

Após concluir este laboratório, você deverá ter uma melhor compreensão dos diferentes métodos para contar as ocorrências de um caractere em uma string.