1. Create an appropriate package for lab 8.
2. Create a class named TextAnalysis.

Start by copying this definition of an array of strings: GreenEggsAndHam.java. Place this definition into your program, inside the class definition, at the very bottom, below your main() method.

Verify that your definition is usable by adding code to your main() method that prints out the total number of words in the array. Mark this test in your file with a comment that says "Exercise 8.2".

Adapt the linear search algorithm in the text to search through an array of words looking for a given target word. Your method should receive an array of strings and a target string from the calling program and return the index at which it finds the target word or -1 if it doesn't find the target word. Be sure to document your method appropriately.

To test that your search method is correct, try a couple test cases on the Green Eggs and Ham array and then create two or three other test arrays of words and try test cases on them as well. Be sure to test the boundary cases (e.g., a null list, empty list, list of one element). Mark the section of your main method that implements these tests as "Exercise 8.3".

You will use this method frequently in later exercises, so save it and be glad for all the testing you’ve done on it.

Write an algorithm for a method that receives an array of words and prints the length of the shortest and the longest word in that array. The method does not return anything. Put your algorithm in your code file as a multi-line comment. When you’re satisfied that your algorithm is correct, implement it and try it out. Leave your algorithm as your method documentation, and document your tests in the main method as "Exercise 8.4".

Start by copying this definition of an array of stop words: StopWords.java. Place this definition into your program, inside the class definition, at the very bottom, below your definition of the Green Eggs and Ham array.

Write an algorithm that counts the number of non-stop words in an array of words. Your method should receive an array of words and an array of stop words and should return the number of words in the first array that are not in the second array. You do not need to keep track of words that you’ve seen before; if a non-stop word occurs in the first array more than once, count it multiple times.

Make use of the search method you implemented in Exercise 8.3 for this algorithm. As in Exercise 8.4, put your algorithm in a multi-line comment in your code file. When you are confident in your algorithm, implement it and try it out. Leave your algorithm in place of the method documentation, and document your tests in the main method as "Exercise 8.5."

Write a method that counts the number of unique words in the text. Consider all the words, including stop words. This problem requires that you keep track of the unique words you’ve seen so far. The following algorithm implements this behavior:

1. Receive an array of strings called list.
2. Set count = 0;
3. If list is not null then
   1. Declare a new array of strings of the same length as list. Call it uniqueWords and initialize each of its elements to an empty string (i.e., "", not null).
   2. Loop for all words in list
      1. If the current word in list is not already in uniqueWords then
         • Set uniqueWords[count] = the current word in list.
         • Increment count by 1.
4. Return count.

Notice a couple things about this algorithm before implementing it:

• It uses a temporary array of unique words to keep track of what it has seen so far as it works through the array. Making this unique words array the same size as the original array ensures that it has enough spaces for all the words in the text, in the case where every word in the text is unique, but it probably uses more space than is necessary. We’ll look at alternate data structures that address this concern later in the course.
• It handles a null , empty or one-word list gracefully.

Implement this algorithm in a method and test it appropriately. Document your method in the standard way (not with the algorithm), and document your tests in the main method as "Exercise 8.6."