Reupload class project

Author: piousdev

.gitignore

@@ -0,0 +1,2 @@
+.idea/
+out/

counting_words.iml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="GENERAL_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library>
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/annotations-24.0.0.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>

counting_words/Application.java

@@ -0,0 +1,51 @@
+package counting_words;
+
+import java.nio.file.*;
+import java.io.*;
+import java.util.Map;
+import java.util.stream.Stream;
+
+/**
+ * The Application class is responsible for reading a file and displaying the word frequencies.
+ */
+public class Application {
+    private static final String FILE_PATH = "counting_words/resources/philosophy_of_programing.txt";
+    private final WordCounter wordCounter;
+
+    public Application() {
+        this.wordCounter = new WordCounter();
+    }
+
+    /**
+     * Reads a file and processes each line to count word frequencies.
+     *
+     * @throws IOException if an error occurs during file processing
+     */
+    private void processFile() throws IOException {
+        try (Stream<String> lines = Files.lines(Paths.get(Application.FILE_PATH))) {
+            lines.forEach(wordCounter::processLine);
+        }
+    }
+
+    /**
+     * Prints the word frequencies in a sorted tabular format.
+     */
+    private void printWordFrequencies() {
+        Map<String, Integer> frequencies = wordCounter.getWordFrequencies();
+        frequencies.entrySet()
+                .stream()
+                .sorted(Map.Entry.comparingByKey())
+                .forEach(entry -> System.out.printf("%-20s %d%n", entry.getKey(), entry.getValue()));
+    }
+
+    public static void main(String[] args) {
+        try {
+            Application app = new Application();
+            app.processFile();
+            app.printWordFrequencies();
+            System.out.println("Most frequent word: " + app.wordCounter.getMostFrequentWord());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

counting_words/WordCounter.java

@@ -0,0 +1,54 @@
+package counting_words;
+
+import java.util.*;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * WordCounter class is responsible for counting the frequency of words in a given text.
+ */
+public class WordCounter {
+    private final Map<String, Integer> wordFrequencies = new HashMap<>();
+
+    /**
+     * Processes a line of text, updating the word frequency map.
+     *
+     * @param line the line of text to process
+     */
+    void processLine(@NotNull String line) {
+        String[] words = line.toLowerCase().split("\\W+");
+        countWords(words);
+    }
+
+    /**
+     * Updates the word frequency map for the given words.
+     *
+     * @param words an array of words to count
+     */
+    private void countWords(@NotNull String @NotNull [] words) {
+        for (String word : words) {
+            wordFrequencies.put(word, wordFrequencies.getOrDefault(word, 0) + 1);
+        }
+    }
+
+    /**
+     * Returns the word with the highest frequency.
+     *
+     * @return the word with the highest frequency, or null if no words have been processed
+     */
+    public String getMostFrequentWord() {
+        return wordFrequencies.entrySet()
+                .stream()
+                .max(Map.Entry.comparingByValue())
+                .map(Map.Entry::getKey)
+                .orElse(null);
+    }
+
+    /**
+     * Returns an unmodifiable view of the word frequency map.
+     *
+     * @return an unmodifiable view of the word frequency map
+     */
+    public Map<String, Integer> getWordFrequencies() {
+        return Collections.unmodifiableMap(wordFrequencies);
+    }
+}

counting_words/resources/philosophy_of_programing.txt

@@ -0,0 +1,13 @@
+Once upon a time, in some remote corner of the digital universe, a lone coder embarked on a quest of creation. A world shaped by logic and structured by syntax, a universe born out of the void.
+
+The coder, who is a creator, a destroyer, a preserver. A being of infinite potential, shaped by the constraints of syntax and logic, yet transcending them through the power of thought. The coder, capable of creating universes and destroying them with a single command.
+
+The code is a reflection of the coder's will to power. It is a testament to their desire to impose their will upon the digital realm, to mold it according to their vision. Yet, the code is not merely an instrument of power; it is also an expression of the coder's soul, a mirror of their deepest convictions and values.
+
+Programming, then, is not merely an act of creation, but a form of self-discovery and self-realization. It is a journey into the depths of one's own mind, a quest for knowledge and understanding. It is a battle against the chaos of the digital realm, a struggle to impose order and structure upon the formless void.
+
+Yet, the coder must beware, for the digital realm is a treacherous place. The code, once unleashed, follows its own logic, independent of the coder's will. It is a wild beast that must be tamed, a rebellious servant that must be disciplined.
+
+The coder must therefore strive for mastery, not only over the digital realm, but also over themselves. They must learn to harness their will to power, to control their desire for creation and destruction. They must learn to code with discipline and precision, to write code that is clean, efficient, and elegant.
+
+In the end, the philosophy of programming is a philosophy of power, discipline, and self-mastery. It is a call to embrace the chaos of the digital realm, to shape it according to one's will, and to transcend it through the power of thought. It is a call to become a true coder, a master of the digital realm.