Contar Ocurrencias de un Carácter

Introducción

En Java, podemos contar fácilmente el número de veces que aparece un carácter específico en una cadena. Esta práctica te guiará a través de diferentes métodos que puedes utilizar para contar las ocurrencias de un carácter en una cadena.

Enfoque Iterativo

Podemos utilizar un enfoque iterativo para recorrer cada carácter en una cadena y contar el número de veces que aparece un carácter específico.

Crea un archivo Java llamado CountOccurrences.java en el directorio ~/project y copia el siguiente contenido al archivo:

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 y ejecutar el programa, ejecuta los siguientes comandos en la terminal:

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

La salida debe ser:

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

Enfoque Recursivo

También podemos utilizar un enfoque recursivo para contar las ocurrencias de un carácter en una cadena. Esto implica utilizar dos métodos, siendo el primero recursivo y el segundo invocando al primero.

Copia y pega el siguiente bloque de código después del bloque de código del Paso 1 en el archivo 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 y ejecutar el programa actualizado, ejecuta los mismos comandos que en el Paso 1:

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

Usando Flujos de Java 8

Podemos utilizar los flujos de Java 8 para contar las ocurrencias de un carácter en una cadena.

Copia y pega el siguiente bloque de código después del bloque de código del Paso 2 en el archivo 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 utilizar el método de flujos de Java 8, agrega la siguiente línea de código al método main después del bloque de código del Paso 2:

usingStreams(s);

Para compilar y ejecutar el programa actualizado, ejecuta los mismos comandos que en el Paso 1:

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

Usando Bibliotecas Externas

Podemos utilizar bibliotecas externas para contar las ocurrencias de un carácter en una cadena.

Usando la Biblioteca Guava

La biblioteca Guava proporciona la clase CharMatcher que puede contar el número de ocurrencias de un carácter dado.

Agrega el siguiente bloque de código después del bloque de código del Paso 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 utilizar la biblioteca Guava, agrega las siguientes importaciones al principio del archivo CountOccurrences.java:

import com.google.common.base.CharMatcher;

En el método main, llama al método usingGuava con el parámetro de cadena:

usingGuava(s);

Para compilar y ejecutar el programa actualizado, ejecuta los mismos comandos que en el Paso 1:

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

Usando la Biblioteca Apache

La biblioteca Apache Commons proporciona una clase StringUtils que tiene un método countMatches() conveniente que toma un carácter y una cadena como entrada y devuelve la cuenta del carácter en esa cadena como salida.

Agrega el siguiente bloque de código después del bloque de código del Paso 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 utilizar la biblioteca Apache Commons, agrega la siguiente importación al principio del archivo CountOccurrences.java:

import org.apache.commons.lang3.StringUtils;

En el método main, llama al método usingApache con el parámetro de cadena:

usingApache(s);

Para compilar y ejecutar el programa actualizado, ejecuta los mismos comandos que en el Paso 1, con un classpath agregado:

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

Resumen

En este laboratorio, cubrimos los siguientes pasos:

1. Enfoque Iterativo - Recorrer cada carácter para contar las ocurrencias de un carácter.
2. Enfoque Recursivo - Utilizar la recursividad para contar las ocurrencias de un carácter.
3. Flujos de Java 8 - Utilizar flujos para contar las ocurrencias de un carácter.
4. Bibliotecas Externas - Utilizar las bibliotecas Guava y Apache para contar las ocurrencias de un carácter.

Después de completar este laboratorio, deberías tener una mejor comprensión de los diferentes métodos para contar las ocurrencias de un carácter en una cadena.