En este artículo sobre programación vamos a ver cómo contar vocales de una cadena en Java.

Es decir, dada una cadena, contar cuántas vocales tiene, sin importar si son mayúsculas o minúsculas.

Para codificar este algoritmo vamos a ver una función que dice si un carácter es vocal, y vamos a usar un HashMap de Java para almacenar el conteo.

Función para saber si char es vocal

Comencemos viendo una función que nos dice si un carácter es una vocal. No es el más efectivo, pero funciona.

Lo que hace es convertir el carácter a cadena, luego lo convierte a minúscula con toLowerCase y finalmente comprueba si está en la cadena “aeiou” con el método contains.

private static boolean esVocal(char letra) {
    return "aeiou".contains(String.valueOf(letra).toLowerCase());
}

Método simple: recorrer y contar

Si no te interesa la frecuencia de vocales y solo quieres saber cuántas hay en la cadena, el código quedaría así, sin mapa:

int vocales = 0;
for (int x = 0; x < cadena.length(); x++) {
    char letraActual = cadena.charAt(x);
    if (esVocal(letraActual)) vocales++;
}
System.out.printf("Vocales en '%s': %d", cadena, vocales);

Continúa leyendo si quieres saber cómo contar la frecuencia de cada vocal.

El mapa para contar vocales de cadena en Java

Vamos a usar la estructura de datos Mapa en Java, a través del HashMap. Si no entiendes mucho sobre el tema, por favor dale un vistazo a mi artículo sobre HashMap en Java.

Para aplicar un truco, las vocales serán la clave y el conteo será el valor. Así que será de tipo String, Integer.

Por defecto, todos los conteos estarán en 0.

// Crear e inicializar mapa
// Tutorial de mapas: https://parzibyte.me/blog/2020/01/07/hashmap-java-tutorial-ejemplos/
HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("a", 0);
hashMap.put("e", 0);
hashMap.put("i", 0);
hashMap.put("o", 0);
hashMap.put("u", 0);

También necesitamos la cadena a la que le vamos a realizar el conteo:

// La cadena a la que le contaremos las vocales
String cadena = "Mi nombre es Luis Cabrera. Tengo un blog en parzibyte.me/blog y aunque no es mi lenguaje favorito, me gusta Java";

El algoritmo para contar vocales de una cadena en Java

Estamos preparados para recorrer la cadena, tomar cada letra, comprobar si es vocal y en caso de que sí, aumentar su conteo.

El código queda así:

// Recorremos la cadena letra por letra y vemos si es una vocal
for (int x = 0; x < cadena.length(); x++) {
    char letraActual = cadena.charAt(x);
    if (esVocal(letraActual)) {
        // La clave es la vocal en sí, pero en minúscula
        String clave = String.valueOf(letraActual).toLowerCase();
        // Aumentamos el conteo en esa clave
        hashMap.put(clave, hashMap.get(clave) + 1);
    }
}

Si es vocal (línea 4) entonces aumentamos el valor en uno (línea 8). Ahora solo basta recorrer el HashMap para mostrar los resultados.

Poniendo todo junto

Una vez que he colocado las funciones y líneas por separado, veamos cómo trabajan todas juntas. Queda así:

/*
 * Archivo: ContarVocalesJava.java
 * Clase: ContarVocalesJava
 * Autor: parzibyte
 * Fecha: 1/7/20 10:16 PM
 * Visita https://parzibyte.me/blog para más tutoriales sobre Java
 */
import java.util.HashMap;

public class ContarVocalesJava {
    public static void main(String[] args) {
        // La cadena a la que le contaremos las vocales
        String cadena = "Mi nombre es Luis Cabrera. Tengo un blog en parzibyte.me/blog y aunque no es mi lenguaje favorito, me gusta Java";

        // Crear e inicializar mapa
        // Tutorial de mapas: https://parzibyte.me/blog/2020/01/07/hashmap-java-tutorial-ejemplos/
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("a", 0);
        hashMap.put("e", 0);
        hashMap.put("i", 0);
        hashMap.put("o", 0);
        hashMap.put("u", 0);

        // Recorremos la cadena letra por letra y vemos si es una vocal
        for (int x = 0; x < cadena.length(); x++) {
            char letraActual = cadena.charAt(x);
            if (esVocal(letraActual)) {
                // La clave es la vocal en sí, pero en minúscula
                String clave = String.valueOf(letraActual).toLowerCase();
                // Aumentamos el conteo en esa clave
                hashMap.put(clave, hashMap.get(clave) + 1);
            }
        }
        System.out.printf("Resultados para '%s':\n", cadena);
        //Imprimir resultados
        for (HashMap.Entry<String, Integer> entry : hashMap.entrySet()) {
            System.out.printf("Vocal: %s. Conteo: %d\n", entry.getKey(), entry.getValue());
        }
    }

    private static boolean esVocal(char letra) {
        return "aeiou".contains(String.valueOf(letra).toLowerCase());
    }
}

Yo lo he ejecutado y funciona perfectamente; si no funciona, deja tu comentario.

Conclusión

Hace algún tiempo hice la implementación de este algoritmo en C, dale una leída si quieres.

Por otro lado, te invito a leer más sobre Java en mi blog.