Hoy vamos a ver un programa para contar la frecuencia de palabras en Java. Es decir, dada una oración, texto o string, contar cuántas veces aparece cada palabra.

Primero vamos a remover el punto, coma, y cosas que no sean palabras usando replaceAll en Java. Luego, vamos a separar la cadena con un delimitador para convertirla a arreglo y tener cada palabra separada.

Finalmente, vamos a usar un mapa de Java o HashMap que nos ayudará a llevar un registro de las palabras que ya hemos encontrado, así como va a permitirnos aumentar el conteo de cada una de ellas.

Preparar cadena para contar frecuencia de palabras en Java

Comencemos viendo cómo vamos a preparar la cadena. En este caso la estoy definiendo en el código pero podría ser leída con la clase Scanner en Java.

Lo que se hace es quitarle signos de puntuación y separarla por espacios para tenerla como arreglo:

// La cadena en donde contamos la frecuencia
String texto = "Go es un lenguaje de programación concurrente y compilado inspirado en la sintaxis de C. Ha sido desarrollado por Google, y sus diseñadores iniciales son Robert Griesemer, Rob Pike y Ken Thompson. Actualmente está disponible en formato binario para los sistemas operativos Windows, GNU/Linux, FreeBSD y Mac OS X, pudiendo también ser instalado en estos y en otros sistemas con el código fuente. Go es un lenguaje de programación compilado, concurrente, imperativo, estructurado, orientado a objetos y con recolector de basura que de momento está soportado en diferentes tipos de sistemas UNIX, incluidos Linux, FreeBSD, Mac OS X y Plan 9 (puesto que parte del compilador está basado en un trabajo previo sobre el sistema operativo Inferno). Las arquitecturas soportadas son i386, amd64 y ARM.";
// Quitar puntos, comas, etcétera. Ver: https://parzibyte.me/blog/2020/01/14/java-remplazar-cadenas-expresion-regular/
texto = texto.replaceAll("[\\.\\,\\(\\)]", "");
// Separar cada palabra por espacio y convertir a arreglo. Ver: https://parzibyte.me/blog/2019/08/08/java-separar-cadena-convertirla-arreglo/
String[] palabras = texto.split(" ");

Ahora que tenemos el arreglo lo vamos a recorrer y contar su frecuencia.

Contando la frecuencia de palabras en Java

La clave o key del mapa en este caso es la palabra, el tipo de dato del mapa es String, Integer; pues la clave será la palabra y el valor será la frecuencia o conteo. Recuerda que ya escribí un tutorial sobre mapas en Java.

En el ciclo que recorre el arreglo vamos a hacer una comparación. Si la palabra ya existe en el mapa, entonces le aumentamos 1 a su conteo.

Si la palabra no existe, la agregamos con un valor inicial de 1. En ambos casos usamos la operación put de los hasmaps.

Quedando así:

// Mapa en donde almacenamos la frecuencia. Ver: https://parzibyte.me/blog/2020/01/07/hashmap-java-tutorial-ejemplos/
HashMap<String, Integer> mapaDeFrecuencias = new HashMap<>();
for (String palabra : palabras) {
    if (mapaDeFrecuencias.containsKey(palabra)) {
        mapaDeFrecuencias.put(palabra, mapaDeFrecuencias.get(palabra) + 1);
    } else {
        mapaDeFrecuencias.put(palabra, 1);
    }
}
// Imprimir mapa
for (HashMap.Entry<String, Integer> entry : mapaDeFrecuencias.entrySet()) {
    System.out.printf("Palabra '%s' con frecuencia %d\n", entry.getKey(), entry.getValue());
}

Al final, imprimimos el mapa recorriéndolo con un foreach y eso mostrará cuántas veces aparece una palabra en el texto.

Poniendo todo junto

El código completo queda así:

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

public class FrecuenciaDePalabrasEnJava {
    public static void main(String[] args) {
        // La cadena en donde contamos la frecuencia
        String texto = "Go es un lenguaje de programación concurrente y compilado inspirado en la sintaxis de C. Ha sido desarrollado por Google, y sus diseñadores iniciales son Robert Griesemer, Rob Pike y Ken Thompson. Actualmente está disponible en formato binario para los sistemas operativos Windows, GNU/Linux, FreeBSD y Mac OS X, pudiendo también ser instalado en estos y en otros sistemas con el código fuente. Go es un lenguaje de programación compilado, concurrente, imperativo, estructurado, orientado a objetos y con recolector de basura que de momento está soportado en diferentes tipos de sistemas UNIX, incluidos Linux, FreeBSD, Mac OS X y Plan 9 (puesto que parte del compilador está basado en un trabajo previo sobre el sistema operativo Inferno). Las arquitecturas soportadas son i386, amd64 y ARM.";
        // Quitar puntos, comas, etcétera. Ver: https://parzibyte.me/blog/2020/01/14/java-remplazar-cadenas-expresion-regular/
        texto = texto.replaceAll("[\\.\\,\\(\\)]", "");
        // Separar cada palabra por espacio y convertir a arreglo. Ver: https://parzibyte.me/blog/2019/08/08/java-separar-cadena-convertirla-arreglo/
        String[] palabras = texto.split(" ");
        // Mapa en donde almacenamos la frecuencia. Ver: https://parzibyte.me/blog/2020/01/07/hashmap-java-tutorial-ejemplos/
        HashMap<String, Integer> mapaDeFrecuencias = new HashMap<>();
        for (String palabra : palabras) {
            if (mapaDeFrecuencias.containsKey(palabra)) {
                mapaDeFrecuencias.put(palabra, mapaDeFrecuencias.get(palabra) + 1);
            } else {
                mapaDeFrecuencias.put(palabra, 1);
            }
        }
        // Imprimir mapa
        for (HashMap.Entry<String, Integer> entry : mapaDeFrecuencias.entrySet()) {
            System.out.printf("Palabra '%s' con frecuencia %d\n", entry.getKey(), entry.getValue());
        }
    }
}

La salida es como se ve en la imagen, contando la frecuencia de cada palabra:

Recuerda que podrías combinar las palabras mayúsculas y minúsculas convirtiéndolas primero a una sola notación.

Te invito a ver más sobre Java en mi blog.