CIT 591 Assignment 6: Word Counter
Fall 2008, David Matuszek

Purposes of this assignment:

• To get you doing some of your own program design.
• To get you more familiar with the Java API (by using the ArrayList class).
• To get you using TDD and JUnit testing.
• To get you familiar with exception handling.

General idea of the assignment:

Read in a list of stop words, one per line. A stop word is an "unimportant" word, like "the" or "of," that doesn't help indicate what the text is all about.

Read in two files, one containing stop words, and one containing English text. Count how many times each word occurs in the second file. Provide methods to determine which are the most common words, and to determine how common particular words are.

Details

Since we have not yet discussed how to read and write files, I am providing the method
    public static ArrayList<String> loadFile(String message) throws IOException.
When called, loadFile() will ask the user for an input file (using the message as the title of a dialog), and will return an arrayList of Strings; each String in the arrayList will represent one line of the file. Copy this method into your project.

Here are the requirements:

• Name your project WordCounter.
• Name your package wordCounter.
• Name your (main) class WordCounter.
  • Give WordCounter a no-argument constructor that uses the provided loadFile method to get (1) the list of stop words and (2) the text to count words in.
  • You may have additional classes if you wish.
• Provide the following public methods:

  public String getWord(int i, boolean includeStopWords)

  Returns the i^th most common word in the file, where 1 indicates the most common, 2 indicates the second most common, etc. All words are returned in lowercase, with no spaces. If there is no i^th word, the method returns null.
  
  Stop words will be included in the counting if includeStopWords is true and ignored if includeStopWords is false.

  public int getWordCount()

  Returns the number of unique words that have been found (not the total word count). In other words, this method returns the rank of the least common word found. Stop words are not included in this count.

  public int getRank(String word, boolean includeStopWords)

  Lowercases the given word and returns its rank (1 represents the most common word), or 0 if the word is not among those that have been counted.
  
  Stop words will be included in the ranking if includeStopWords is true and ignored if includeStopWords is false.

• An apostrophe is part of a word if and only if it has a letter on each side of it (Example: it's).
• Don't treat hyphens as parts of words.
• You may write as many additional methods as you like. All additional methods should have "package" (default) visibility.
• Provide complete JUnit tests for all methods that you write.
• Methods should not print anything, unless printing is the only purpose of that method. JUnit testing should never result in printed output.
• Keep all your methods short. If you have to scroll to see the complete method, it is much too long.
• Make all instance variables and class variables private unless you have a good reason to do otherwise.
• Make sure your name and your partner's name are in every class that you write. (Use @author tags.)
• Make sure that all your code is formatted according to standards.
• Use descriptive and accurate names for your variables and your methods.
• Write proper Javadoc comments for all methods. (Javadoc will be discussed in detail in a forthcoming lecture.)
• Obey the DRY principle, and don't repeat code unnecessarily.
• Turn in a proper zip file, not some weird system-dependent variant. See my Using Zip Files and Blackboard page for instructions.

You do not need a main method; all your testing can be done from JUnit.

Provided code:

// import java.io.*and java.util.ArrayList;

public static ArrayList<String> loadFile(String message) throws IOException {       
    BufferedReader reader = null;
    ArrayList lines = null;
    JFileChooser chooser = new JFileChooser();
    
    chooser.setDialogTitle(message);
    int result = chooser.showOpenDialog(null);
    if (result == JFileChooser.APPROVE_OPTION) {
        File file = chooser.getSelectedFile();
        if (file != null) {
            String fileName = file.getCanonicalPath();
            reader = new BufferedReader(new FileReader(fileName));
            lines = new ArrayList<String>();
            String line = reader.readLine();
            while (line != null) {
                lines.add(line);
                line = reader.readLine();
            }
        }
    }
    return lines;
} 

About ArrayList<String>:

An ArrayList<String> is like an array, except that it doesn't have a fixed size; it can be expanded as needed. Since you don't know how many words you are going to encounter, you need an ArrayList instead of an array.

The angle brackets are an odd syntax that we haven't yet talked about. Just think of the whole thing, ArrayList<String>, as meaning an ArrayList that contains Strings. Use it just like an ordinary class name. So you can say things like
    ArrayList<String> words = new ArrayList<String>();
and it will work fine.

You can create an ArrayList of any object type, for example, ArrayList<Integer>. You can't create an array list of a primitive type, for example, ArrayList<int>.

For planning what methods you will need, you can assume that you can do anything with an ArrayList<String> that you can do with String[] array, but you can also change its size by adding and removing things. You just don't get to use the special [] syntax; you have to use Object syntax.

ArrayLists are described in the Java API, in the java.util package.

Advice:

• Start by figuring out what methods you will need. Decide who will write which methods.
• JUnit tests will be a lot easier to write, and to get correct, if you write the tests before you write the methods to be tested.
• Whoever writes a method should also write the tests for that method. Experience shows that, unless you can work side-by-side, it is a bad idea for one partner to write tests for the other partner's code.
• Properly formatted code is easier to read and debug. Don't wait until the end to format it.

Due Date:

Thursday, October 23, before midnight. Submit to Blackboard one copy of your project directory, properly zipped. Both your names should be in Javadoc comments in the classes. In addition, whichever of you turns the program in, should put your partner's name in the comments field in Blackboard.