Assignment No.10 implements classes.

3 files changed, 262 insertions, 0 deletions

diff --git a/src/de/fhswf/in/inf/java1/aufgabe10/LineWordCount.java b/src/de/fhswf/in/inf/java1/aufgabe10/LineWordCount.java
new file mode 100644
index 0000000..e4356a3
--- /dev/null
+++ b/src/de/fhswf/in/inf/java1/aufgabe10/LineWordCount.java
@@ -0,0 +1,79 @@
+/**
+ * 
+ */
+package de.fhswf.in.inf.java1.aufgabe10;
+
+import java.util.concurrent.ConcurrentSkipListMap;
+
+/**
+ * Counts the words in one line.
+ *
+ * @author $Author: $
+ * @version $Revision: $, $Date: $ UTC
+ */
+public class LineWordCount implements Runnable
+{
+
+   private String[] lineArray;
+
+   private ConcurrentSkipListMap<String, Integer> lineWordMap;
+
+   private static final Integer NEWVALUE = new Integer(1);
+
+   /**
+    * Creates the object which will be threaded.
+    *
+    * @param wordMap
+    *           The wordMap into which the counts should be added.
+    * @param line
+    *           The line to be counted.
+    */
+   public LineWordCount(ConcurrentSkipListMap<String, Integer> wordMap,
+         String line)
+   {
+      if (wordMap == null)
+      {
+         throw new IllegalArgumentException("WordMap can't be null.");
+      }
+      if (line == null)
+      {
+         throw new IllegalArgumentException("Line can't be null.");
+      }
+      if (line.isEmpty())
+      {
+         throw new IllegalArgumentException("Line can't be empty.");
+      }
+      lineWordMap = wordMap;
+      lineArray = line.split("[^\\p{IsAlphabetic}\\p{Digit}]+");
+   }
+
+   /*
+    * (non-Javadoc)
+    * 
+    * @see java.lang.Runnable#run()
+    */
+   @Override
+   public final void run()
+   {
+      for (String word : lineArray)
+      {
+         // Split creates empty String, if first char is a split char.
+         if (!word.isEmpty())
+         {
+            word = word.toLowerCase();
+            boolean success;
+
+            do
+            {
+               success = true;
+               Integer tmp = lineWordMap.putIfAbsent(word, NEWVALUE);
+               if (tmp != null)
+               {
+                  success = lineWordMap.replace(word, tmp, tmp + 1);
+               }
+            }
+            while (!success);
+         }
+      }
+   }
+}
diff --git a/src/de/fhswf/in/inf/java1/aufgabe10/ParallelWordCount.java b/src/de/fhswf/in/inf/java1/aufgabe10/ParallelWordCount.java
new file mode 100644
index 0000000..5793f02
--- /dev/null
+++ b/src/de/fhswf/in/inf/java1/aufgabe10/ParallelWordCount.java
@@ -0,0 +1,135 @@
+/**
+ * 
+ */
+package de.fhswf.in.inf.java1.aufgabe10;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A class, that counts words in files.
+ *
+ * @author $Author: $
+ * @version $Revision: $, $Date: $ UTC
+ */
+public class ParallelWordCount
+{
+
+   private static final int TIMEOUT = 30;
+
+   private ConcurrentSkipListMap<String, Integer> wordMap;
+
+   /**
+    * Empty constructor.
+    *
+    */
+   public ParallelWordCount()
+   {
+   }
+
+   /**
+    * Reads a file and counts the words.
+    *
+    * @param file
+    *           The file to be read.
+    */
+   public final void readFile(File file)
+   {
+
+      try (BufferedReader f = new BufferedReader(new FileReader(file)))
+      {
+         if (wordMap == null)
+         {
+            wordMap = new ConcurrentSkipListMap<>();
+         }
+
+         wordMap.clear();
+
+         String line = null;
+
+         ExecutorService executer = Executors.newFixedThreadPool(Runtime
+               .getRuntime().availableProcessors());
+
+         while ((line = f.readLine()) != null)
+         {
+            Runnable worker = new LineWordCount(wordMap, line);
+            executer.execute(worker);
+         }
+
+         executer.shutdown();
+         boolean success = false;
+         try
+         {
+            success = executer.awaitTermination(TIMEOUT, TimeUnit.SECONDS);
+         }
+         catch (InterruptedException e)
+         {
+            e.printStackTrace();
+         }
+         if (!success)
+         {
+            wordMap = null;
+            throw new IllegalStateException(
+                  "Waiting for threads has timed out.");
+         }
+
+      }
+      catch (IOException e)
+      {
+         e.printStackTrace(System.err);
+      }
+   }
+
+   /**
+    * Returns all words from the file.
+    *
+    * @return An unmodifiable Set of the words from the file.
+    */
+   public final Set<String> getWords()
+   {
+      if (wordMap == null)
+      {
+         throw new IllegalStateException("First a file must be read.");
+      }
+      return Collections.unmodifiableSet(wordMap.keySet());
+   }
+
+   /**
+    * Returns the count of a word in a file.
+    *
+    * @param word
+    *           The file to be counted.
+    * @return Returns the count of findings in the file.
+    */
+   public final int getCount(String word)
+   {
+      if (wordMap == null)
+      {
+         throw new IllegalStateException("First a file must be read.");
+      }
+      if (word == null)
+      {
+         throw new IllegalArgumentException("Word must be a valid referece.");
+      }
+      if (word.isEmpty())
+      {
+         throw new IllegalArgumentException("The word can't be empty.");
+      }
+
+      Integer tmp = wordMap.get(word);
+      if (tmp == null)
+      {
+         return 0;
+      }
+      return tmp;
+   }
+
+}
diff --git a/src/de/fhswf/in/inf/java1/aufgabe10/WordCountTest.java b/src/de/fhswf/in/inf/java1/aufgabe10/WordCountTest.java
new file mode 100644
index 0000000..6d9b12c
--- /dev/null
+++ b/src/de/fhswf/in/inf/java1/aufgabe10/WordCountTest.java
@@ -0,0 +1,48 @@
+/**
+ * 
+ */
+package de.fhswf.in.inf.java1.aufgabe10;
+
+import java.io.File;
+
+/**
+ * Tests the ParallelWordCount class.
+ *
+ * @author $Author: $
+ * @version $Revision: $, $Date: $ UTC
+ */
+public final class WordCountTest
+{
+
+   /**
+    * Private constructor for utility class.
+    *
+    */
+   private WordCountTest()
+   {
+   }
+
+   /**
+    * Tests the ParallelWordCount class.
+    *
+    * @param args
+    *           Command line arguments.
+    */
+   public static void main(String[] args)
+   {
+      File file = new File(
+            "/home/aentfs/workspace/Java1/misc/Blatt9TestFile2.txt");
+
+      ParallelWordCount tmp = new ParallelWordCount();
+      tmp.readFile(file);
+      for (String word : tmp.getWords())
+      {
+         System.out.println("Wort \"" + word + "\" kommt "
+               + tmp.getCount(word) + " mal vor.");
+      }
+      System.out.println("Wort \"fgh\" kommt "
+            + tmp.getCount("fgh") + " mal vor.");
+
+   }
+
+}