Question

This last lab teaches you to think and solve problems in the functional programming framework of the Java 8 computation streams. Therefore in this lab, you are absolutely forbidden to use any conditional statements (either if or switch), loops (either for, while or do-while) or even recursion. All computation must be implemented using only computation streams and their operations!

In this lab, we also check out the Java NIO framework for better file operations than those offered in the old package java.io and the class File. Your methods receive a Path as an argument, referring to the text file in your file system whose contents your methods will then process with computation streams. Write both of the following methods inside a new class named StreamExercises.

public int countLines(Path path, int thres) throws IOException

This method should first use the utility method Files.lines to convert the given path into an instance of Stream<String> that produces the lines of this text file as a stream of strings, one line at the time. The method should then use filter to keep only those whose length is greater or equal to the threshold value thres, and in the end, return a count how many such lines the file contains.

public List<String> collectWords(Path path) throws IOException

This method should also use the same utility method Files.lines to first turn its parameter path into a Stream<String>. Each line should be converted to lowercase and broken down to individual words that are passed down the stream as separate String objects (the stream operation flatMap will be handy here). Split each line into its individual words using the separator regex "[^a-z]+" for the method split in String. In the next stages of the computation stream, discard all empty words, and sort the remaining words in alphabetical order. Multiple consecutive occurrences of the same word should then be removed (use the stream operation distinct, or if you want to do this yourself the hard way as an exercise, write a custom Predicate<String> subclass whose method test accepts its argument only if it was the first one or distinct from the previous argument), and to wrap up this computation stream, collected into a List<String> that is returned as the answer.

*TEST FILE*

import java.util.*;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.nio.file.*;
import java.io.*;

public class StreamExercisesTest {
    
    private static int TRIALS = 10000;
    private static int SEED = 9999;
    
    @Test
    public void testCountLines() {
        StreamExercises se = new StreamExercises();
        try {
            assertEquals(se.countLines(Paths.get("warandpeace.txt"), 70), 21079);
        }
        catch(IOException e) {
            System.out.println("Unable to read warandpeace.txt!");
            assertTrue(false);
        }
    }
    
    @Test
    public void testCollectWords() {
        StreamExercises se = new StreamExercises();
        try {
            List<String> words = se.collectWords(Paths.get("warandpeace.txt"));
            assertEquals(17465, words.size());
            assertEquals("accomplished", words.get(100));
            assertEquals("sundays", words.get(15000));
        }
        catch(IOException e) {
            System.out.println("Unable to read warandpeace.txt!");
            assertTrue(false);
        }
        
    }
}

Answer 1

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamExercises {
    public int countLines(Path path, int thres) throws IOException{
        Stream<String> lines = Files.lines(path); // to get lines from file
        Stream<String> l =  lines.filter(line -> line.length() >= thres); // filter lines which are less than threshold length
        return (int) l.count(); // return the number of lines
    }

    public List<String> collectWords(Path path) throws IOException{
        Stream<String> lines = Files.lines(path); // extract lines from file
        Stream<String> l = lines.map(line -> line.toLowerCase()); // convert lines to lower case
        Stream<String> words = l.map(line-> line.split("[^a-z]+")).flatMap(Arrays::stream); // split the lines to extract word using regex and then flattening the Stream<String[]> to Strema<String>
        Stream<String> noempty_word = words.filter(word -> word.length() > 0).sorted(); // removing empty words and then sorting the stream of words
        List<String> ans = noempty_word.distinct().collect(Collectors.toList()); // extracting distinct words and converting them to list
        return ans; returning resulting list
    }
}

Explanation:

CountLines Funtion:

Stream<String> lines = Files.lines(path) : This line extract lines from file and assign it to Stream of string.

Stream<String> l =  lines.filter(line -> line.length() >= thres) : This line uses a stream function to filter out those lines whose length is greater than thresholde value.

return (int) l.count() : This line returns the count of lines as an int.

collectWords Function:

Stream<String> lines = Files.lines(path):  This line extract lines from file and assign it to Stream of string. 

Stream<String> l = lines.map(line -> line.toLowerCase()) : convert each line in Stream to lower case.

Stream<String> words = l.map(line-> line.split("[^a-z]+")).flatMap(Arrays::stream) : split lines to etract word using regex and then flattening Stream of Stream of String to Stream of String.

Stream<String> noempty_word = words.filter(u -> u.length() > 0).sorted() : remove empty words from word Stream and sorts the word in alphabetical order.

List<String> ans = noempty_word.distinct().collect(Collectors.toList()) : filter out distinct words and covert them into list of string .

return ans :  return the list