Programa Java para encontrar la palabra más repetida en un archivo de texto

Mapa y Mapa. La interfaz de entrada se usará ya que la interfaz de mapa asigna claves únicas a valores. Una clave es un objeto que se utiliza para recuperar un valor en una fecha posterior. La interfaz Map.Entry le permite trabajar con una entrada de mapa. Además, usaremos la clase HashMap para almacenar elementos en pares «clave/valor» y acceder a ellos mediante un índice de otro tipo.

Ilustración:

Supongamos que el contenido del archivo de texto de muestra es el siguiente:

Entrada: un archivo de texto que contiene una secuencia de palabras arbitrarias 

“¿Cómo contar el número de ocurrencias de cada palabra? Cómo contar el número o cada palabra en string. Cálculo de la frecuencia de cada palabra en una oración en Java.”

Salida: Lista de palabras que tienen la máxima ocurrencia

in = 3
each = 3
of = 3
to = 3

Implementación: la imagen de entrada del archivo de muestra es la siguiente:

Ejemplo

Java

// Java Program to Find the
// Most Repeated Word in a Text File
 
// Importing File classes
import java.io.File;
import java.io.FileNotFoundException;
// Importing Map and HashMap class from
// java.util package
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
// Importing Scanner class to
// take input from the user
import java.util.Scanner;
 
// Class
// To find maximum occurrences
public class GFG {
 
    // Method 1 - getWords()
    // Reading out words from the file and
    // mapping key value pair corresponding to
    // each different word
    static void getWords(String fileName,
                         Map<String, Integer> words)
        throws FileNotFoundException
    {
        // Creating a Scanner class object
        Scanner file = new Scanner(new File(fileName));
 
        // Condition check using hasNext() method which
        // holds true till there is word being read from the
        // file.
      // As the end of file content,condition violates
        while (file.hasNext()) {
 
            // Reading word using next() method
            String word = file.next();
 
            // Frequency count variable
            Integer count = words.get(word);
 
            // If the same word is repeating
            if (count != null) {
 
                // Incrementing corresponding count by unity
                // every time it repeats
              // while reading from the file
                count++;
            }
            else
 
                // If word never occurred after occurring
                // once, set count as unity
                count = 1;
            words.put(word, count);
        }
 
        // Close the file and free up the resources
        file.close();
    }
 
    // Method 2 - getMaxOccurrence()
    // To get maximum occurred Word
    static int getMaxOccurrence(Map<String, Integer> words)
    {
        // Initially set maximum count as unity
        int max = 1;
 
        // Iterating over above Map using for-each loop
        for (Entry<String, Integer> word :
             words.entrySet()) {
 
            // Condition check
            // Update current max value  with the value
            // exceeding unity in Map while traversing
            if (word.getValue() > max) {
                max = word.getValue();
            }
        }
 
        // Return the maximum value from the Map
        return max;
    }
 
    // Method 3
    // Main driver method
    public static void main(String[] args)
        throws FileNotFoundException
    {
        // Creating an object of type Map
        // Declaring object of String and Integer types
        Map<String, Integer> words
            = new HashMap<String, Integer>();
 
        // Retrieving the path as parameter to Method1()
        // above to get the file to be read
        getWords("C:\\Users\\dell\\sample.txt", words);
 
        // Variable holding the maximum
        // repeated word count in a file
        int max = getMaxOccurrence(words);
 
        // Traversing using fo-each loop
        // Creating a set out of same elements
        // contained in a HashMap
        for (Entry<String, Integer> word :
             words.entrySet()) {
 
            // Comparing values using geValue() method
            if (word.getValue() == max) {
 
                // Print and display word-count pair
                System.out.println(word);
            }
        }
    }

Producción:

Publicación traducida automáticamente

Artículo escrito por pawki y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *