Поиск наиболее часто встречающегося слова в текстовом файле

Question

Я создал консольное приложение, предназначенное для отображения наиболее часто встречающихся слов в текстовом файле. Пожалуйста, смотрите код, который следует:

public class Main
{

    public static void main(String[] args)
    {

        readTextFile();

    }


    private static void readTextFile()
    {
        final String path = C://Users//Geffrey//IdeaProjects//test.txt";

        File file = new File(path);
        BufferedReader bufferedReader = null;
        try
        {
            bufferedReader = new BufferedReader(new FileReader(file));

        } catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }

        String inputLine = null;
        Map<String, Integer> wordMap = new HashMap<>();


        try
        {
            while ((inputLine = bufferedReader.readLine()) != null)
            {
                String[] words = inputLine.split("[.,;:!?(){}— \\s]"); //

                for (int count = 0; count < words.length; count++)
                {
                    String key = words[count].toLowerCase(); // remove .toLowerCase for Case Sensitive result.
                    if (key.length() > 0)
                    {
                        if (wordMap.get(key) == null)
                        {
                            wordMap.put(key, 1);
                        } else
                        {
                            int value = wordMap.get(key).intValue();
                            value++;
                            wordMap.put(key, value);
                        }
                    }
                }
            }

            List<WordComparable> topOccurrence = findMaxOccurance(wordMap, 1);
            System.out.println("Most Frequent word: " + topOccurrence.get(0).wordFromFile + " occurred " + topOccurrence.get(0).numberOfOccurrence + " times");  //Maixmum Occurance of Word in file:

        } catch (IOException error)
        {
            System.out.println("Invalid File");
        } finally
        {
            try
            {
                bufferedReader.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }





    }



    public static List<WordComparable> findMaxOccurance(Map<String, Integer> map, int n)
    {
        List<WordComparable> list = new ArrayList<>();
        for (Map.Entry<String, Integer> entry : map.entrySet())
            list.add(new WordComparable(entry.getKey(), entry.getValue()));

        Collections.sort(list);
        return list;
    }

Класс WordComparable:

public class WordComparable implements Comparable<WordComparable>
{
    public String wordFromFile;
    public int numberOfOccurrence;

    public WordComparable(String wordFromFile, int numberOfOccurrence)
    {
        super();
        this.wordFromFile = wordFromFile;
        this.numberOfOccurrence = numberOfOccurrence;
    }

    @Override
    public int compareTo(WordComparable arg0)
    {
        int wordCompare = Integer.compare(arg0.numberOfOccurrence, this.numberOfOccurrence);
        return wordCompare != 0 ? wordCompare : wordFromFile.compareTo(arg0.wordFromFile);

    }

    @Override
    public int hashCode()
    {
        final int uniqueNumber = 19;
        int wordResult = 9;
        wordResult = uniqueNumber * wordResult + numberOfOccurrence;
        wordResult = uniqueNumber * wordResult + ((wordFromFile == null) ? 0 : wordFromFile.hashCode());
        return wordResult;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        WordComparable other = (WordComparable) obj;
        if (numberOfOccurrence != other.numberOfOccurrence)
            return false;
        if (wordFromFile == null)
        {
            if (other.wordFromFile != null)
                return false;
        } else if (!wordFromFile.equals(other.wordFromFile))
            return false;
        return true;
    }
}

Мой вопрос - это мое решение, наиболее эффективный способ решения этой проблемы, и если нет, какие другие изменения я могу внести для улучшения своего кода.

Answer 1

Вместо HashMap вы можете рассмотреть создание очереди с максимальным приоритетом (классическая куча с максимальным значением).

Если вы используете maxheap, вы можете найти самое частое слово за O (1) раз.