Completed solution

concurrent-linked-queue-simple/src/main/java/com/bobocode/ConcurrentLinkedQueue.java

@@ -1,29 +1,65 @@
 package com.bobocode;
 
+import java.util.concurrent.atomic.AtomicInteger;
+
 /**
  * This queue should be implemented using generic liked nodes. E.g. class Node<T>. In addition, this specific
  * should be thread-safe, which means that queue can be used by different threads simultaneously, and should work correct.
  *
  * @param <T> a generic parameter
  */
 public class ConcurrentLinkedQueue<T> implements Queue<T> {
+    static final class Node<T> {
+        private T element;
+        private Node<T> next;
+
+        static <T> Node<T> valueOf(T element) {
+            return new Node<>(element);
+        }
+
+        private Node(T element) {
+            this.element = element;
+        }
+    }
+
+    private Node<T> head;
+    private Node<T> tail;
+    private AtomicInteger size = new AtomicInteger();
+
     @Override
-    public void add(T element) {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+    synchronized public void add(T element) {
+        Node<T> newNode = Node.valueOf(element);
+        if (head == null) {
+            head = tail = newNode;
+        } else {
+            tail.next = newNode;
+            tail = newNode;
+        }
+        size.incrementAndGet();
     }
 
     @Override
-    public T poll() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+    synchronized public T poll() {
+        if (head != null) {
+            T element = head.element;
+            head = head.next;
+            if (head == null) {
+                tail = null;
+            }
+            size.decrementAndGet();
+            return element;
+        } else {
+            return null;
+        }
     }
 
     @Override
     public int size() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return size.get();
     }
 
     @Override
     public boolean isEmpty() {
-        throw new UnsupportedOperationException("This method is not implemented yet"); // todo: implement this method
+        return head == null;
     }
 }

file-reader/src/main/java/com/bobocode/FileReaderException.java

@@ -0,0 +1,7 @@
+package com.bobocode;
+
+public class FileReaderException extends RuntimeException {
+    public FileReaderException(String message, Exception e) {
+        super(message, e);
+    }
+}

file-reader/src/main/java/com/bobocode/FileReaders.java

@@ -1,5 +1,16 @@
 package com.bobocode;
 
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.joining;
+
 /**
  * {@link FileReaders} privides an API that allow to read whole file into a {@link String} by file name.
  */
@@ -12,6 +23,27 @@ public class FileReaders {
      * @return string that holds whole file content
      */
     public static String readWholeFile(String fileName) {
-        throw new UnsupportedOperationException("It's your job to make it work!"); //todo
+        Path filePath = createPathFromFileName(fileName);
+        try (Stream<String> fileLinesStream = openFileLinesStream(filePath)) {
+            return fileLinesStream.collect(joining("\n"));
+        }
+    }
+
+    private static Stream<String> openFileLinesStream(Path filePath) {
+        try {
+            return Files.lines(filePath);
+        } catch (IOException e) {
+            throw new FileReaderException("Cannot create stream of file lines!", e);
+        }
+    }
+
+    private static Path createPathFromFileName(String fileName) {
+        Objects.requireNonNull(fileName);
+        URL fileUrl = FileReaders.class.getClassLoader().getResource(fileName);
+        try {
+            return Paths.get(fileUrl.toURI());
+        } catch (URISyntaxException e) {
+            throw new FileReaderException("Invalid file URL",e);
+        }
     }
 }

file-stats/src/main/java/com/bobocode/FileStats.java

@@ -1,18 +1,76 @@
 package com.bobocode;
 
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+import static java.util.function.Function.identity;
+import static java.util.stream.Collectors.counting;
+import static java.util.stream.Collectors.groupingBy;
+
 /**
  * {@link FileStats} provides an API that allow to get character statistic based on text file. All whitespace characters
  * are ignored.
  */
 public class FileStats {
+    private final Map<Character, Long> characterCountMap;
+    private final char mostPopularCharacter;
+
     /**
      * Creates a new immutable {@link FileStats} objects using data from text file received as a parameter.
      *
      * @param fileName input text file name
      * @return new FileStats object created from text file
      */
     public static FileStats from(String fileName) {
-        throw new UnsupportedOperationException("It's your job to make it work!"); //todo
+        return new FileStats(fileName);
+    }
+
+    private FileStats(String fileName) {
+        Path filePath = getFilePath(fileName);
+        characterCountMap = computeCharacterMap(filePath);
+        mostPopularCharacter = findMostPopularCharacter(characterCountMap);
+    }
+
+    private Path getFilePath(String fileName) {
+        Objects.requireNonNull(fileName);
+        URL fileUrl = getFileUrl(fileName);
+        try {
+            return Paths.get(fileUrl.toURI());
+        } catch (URISyntaxException e) {
+            throw new FileStatsException("Wrong file path", e);
+        }
+    }
+
+    private URL getFileUrl(String fileName) {
+        URL fileUrl = getClass().getClassLoader().getResource(fileName);
+        if (fileUrl == null) {
+            throw new FileStatsException("Wrong file path");
+        }
+        return fileUrl;
+    }
+
+    private Map<Character, Long> computeCharacterMap(Path filePath) {
+        try (Stream<String> lines = Files.lines(filePath)) {
+            return collectCharactersToCountMap(lines);
+        } catch (IOException e) {
+            throw new FileStatsException("Cannot read the file", e);
+        }
+    }
+
+    private Map<Character, Long> collectCharactersToCountMap(Stream<String> linesStream) {
+        return linesStream
+                .flatMapToInt(String::chars)
+                .filter(a -> a != 32) // filter whitespace
+                .mapToObj(c -> (char) c)
+                .collect(groupingBy(identity(), counting()));
     }
 
     /**
@@ -22,7 +80,7 @@ public static FileStats from(String fileName) {
      * @return a number that shows how many times this character appeared in a text file
      */
     public int getCharCount(char character) {
-        throw new UnsupportedOperationException("It's your job to make it work!"); //todo
+        return characterCountMap.get(character).intValue();
     }
 
     /**
@@ -31,7 +89,15 @@ public int getCharCount(char character) {
      * @return the most frequently appeared character
      */
     public char getMostPopularCharacter() {
-        throw new UnsupportedOperationException("It's your job to make it work!"); //todo
+        return mostPopularCharacter;
+    }
+
+    private char findMostPopularCharacter(Map<Character, Long> characterCountMap) {
+        return characterCountMap.entrySet()
+                .stream()
+                .max(Comparator.comparing(Map.Entry::getValue))
+                .get()
+                .getKey();
     }
 
     /**
@@ -41,6 +107,6 @@ public char getMostPopularCharacter() {
      * @return {@code true} if this character has appeared in the text, and {@code false} otherwise
      */
     public boolean containsCharacter(char character) {
-        throw new UnsupportedOperationException("It's your job to make it work!"); //todo
+        return characterCountMap.containsKey(character);
     }
 }