Baby Names (due 19 Nov 2011)

Complete a program that allows a user to query a data base of the 1000 most popular baby names in the United States per decade for the past 11 decades under the constraints described below. As always, you may add helper methods and should do so to provide structure to the program and reduce redundancy. One additional constraint: You must use ArrayList class in the solution. You are encouraged to use methods in the String and ArrayList class to make the program easier to write. The ArrayList class has lots of methods that can make your job easier and one of the goals of this assignment is to learn those methods. Do not try to do everything by hand with the get method and loops. Make use of the methods in ArrayList.

Your program will be processing a file with data obtained from the Social Security Administration. They provide a web site showing the distribution of names chosen for children over the last 100 years in the US (www.ssa.gov/OACT/babynames/).

The data represent the 1000 most popular boy and girl names for children born in the US going back to 1900. The data can be boiled down to a single text file as shown below. On each line we have the name, followed by the rank of that name in 1900, 1910, 1920, ..., 2000 (11 numbers). A rank of 1 was the most popular name that year, while a rank of 997 was not very popular. A 0 means the name did not appear in the top 1000 that year at all. The lines are in alphabetical order.

...
Sam 58 69 99 131 168 236 278 380 467 408 466
Samantha 0 0 0 0 0 0 272 107 26 5 7
Samara 0 0 0 0 0 0 0 0 0 0 886
Samir 0 0 0 0 0 0 0 0 920 0 798
Sammie 537 545 351 325 333 396 565 772 930 0 0
Sammy 0 887 544 299 202 262 321 395 575 639 755
Samson 0 0 0 0 0 0 0 0 0 0 915
Samuel 31 41 46 60 61 71 83 61 52 35 28
Sandi 0 0 0 0 704 864 621 695 0 0 0
Sandra 0 942 606 50 6 12 11 39 94 168 257
...

Note, a 0 in the data file means the name was not ranked in the top 1000 for the corresponding decade. It has some unknown rank greater than 1000. When you store a 0 from the data file in your NameRecord objects you may use something other than 0 if you think it will make your algorithms easier to implement. (Recall altering the way data is stored to fit our needs is part of the magic of programming.)

We see that Sam was #58 in 1900 and is slowly moving down. Samantha is moving up strong to #7. Samir barely appears in 1980, but by 2000 is up to #798. The database is for children born in the US, so ethnic trends show up when immigrants have kids.

You are provided with one class, NameSurfer.java . This is the main driver class. When the main() method of this class is called it opens a window to pick the file with the names in it. The file is called names.txt. After creating the database of names encapsulated in a class called Names.java the program displays a menu and allows the user to make various queries of the database. The provided version of names shows five of the options and you will add two more.

Suggested steps for implementing the program.

0. These suggested steps describe implementing the requirements. You may add more methods if you want. You may store data in a different form than the input file. For example, the files uses a 0 to indicate the name had a rank greater than 1000 for a given decade. You can store a value other than 0 if you want. (The value for not ranked in a given decade is on the other side of the wall of abstraction.)

1. Implement and test the class called NameRecord. Objects of this type store the data for an individual name, including the name itself (a String) and the rank of the name for each of the 11 decades. The ranks for each decade must be stored in an ArrayList of Integers. The class must have the following properties:

• A constructor that takes a String as in the file above and initializes the data for the NameRecord object. How do you parse the String into the name and the years? You should either user the split method from the String class or a Scanner object. If you use the split method from the String class the statement would be:
  
  String[] parsedData = data.split("\\s+"); //data is the input String
  
  This parses the String into its individual components using whitespace as delimiters. The name itself should be in the first element of the resulting array and the 11 ranks will be in the remaining elements, although they will be Strings. You will have to convert them to ints using the Integer.parseInt method.
  
  The other approach for parsing the input is to use a Scanner object.
  
  Scanner lineScanner = new Scanner(data); //data is the input String
  
  Once the Scanner object is created you can use the next method to pull out the name and then the nextInt method to pull out the ranks. See the Java documentation for more details on the split method from the String class and Scanner objects.
  
• implement a method to get the name for this NameRecord.
  
• implement a method that returns this NameRecords rank for a given decade. You can use the convention that 1900 is 0, 1910 is 1, and so forth. In other words the parameter will be between 0 to get the rank during the 1900s, 1 to get the rank during the 1910s, and so forth.
  
• implement a method that returns an int for this NameRecords best decade. In other words it returns the decade this name was most popular, using the most recent decade in the event of a tie. Return the actual decade such as 1900, 1910, and so forth. Looking at the data above Samir's was most popular in 2000 while Sandra's best decade was 1940. This method shall return 1900, 1910, 1920, or the other valid decades, not the codes 0, 1, 2, ... In case of a tie, return the most recent decade. For example if the name David's best rank was number 2 and it occurred in 1950, 1960, and 1980 the method would return 1980, the most recent decade.
  
• implement a method that returns the number of decades this name has been ranked.
  
• implement a method that returns true if this name has ranked in every decade
  
• implement a method that returns true if this name has been ranked in only one decade
  
• implement a method that returns true if this name has been getting more popular every decade in the time period covered. This will be true if every decades rank is better (closer to 1) than the previous decade. The rank must improve every decade, it cannot be equal to the previous decade. So for example if the ranks were 0 950 900 875 850 800 750 700 650 600 500 400 are always improving. The ranks 0 0 0 800 850 800 750 700 650 600 500 400 are not always improving. Recall a 0 means the name did not appear in the top 1000 names for that decade. (When the rank is 0 indicating a name wasn't in the top 1000 in two consecutive decades we can't really decide one way or another if it improved from one decade to the next. So we assume it was not getting more popular.)
  
• implement a method that returns true if this name has been getting less popular every decade in the time period covered. This will be true if every decades rank is worse than the previous decade. The rank must get worse, it cannot be equal to the previous decade. So for example the ranks 100 150 200 202 250 300 350 400 450 460 0 are always getting worse. The ranks 100 150 200 202 250 300 350 400 0 0 0 are not always getting worse.

After completing all these methods you should thoroughly test the NameRecord class using individual lines from the names.txt file or with your own data. Include your testing code in your NameSurfer class even though it will not be called when the program is run. Part of the assignment grade will be based on the tests you write for the NameRecord class.

2. Implement and test the Names class. This class stores all of the NameRecord objects in an ArrayList. (private ArrayList<NameRecord> names) This class must have the following methods.

• A constructor that takes in a Scanner object. The Scanner object will already be hooked up to the names.txt file. The constructor will go use the Scanner to go through all the names in the file and create a NameRecord object for each one. This can be done with the following code:
  
  String line
  while( fileScanner.hasNextLine() )
  {
  line = fileScanner.nextLine();
  /* create a NameRecord object based on line and add it to the ArrayList of NameRecord objects */
  }
  
  You may assume each line of the file has one name and its 11 ranks, in order, for the decades from 1900 to 2000, but your program should be easy to change to to handle other data sets with a different number of decades and a different start decade.
  
• A method that returns an ArrayList of NameRecord objects that contain a given substring, ignoring case.
  
• A method that returns the NameRecord whose name is equal to a given String ignoring case. If there is no NameRecord that completely matches the given String return null.
  
• A method that returns an ArrayList of Strings of names that have been ranked in every decade.
  
• A method that returns an ArrayList of Strings of names that have been ranked in only one decade.
  
• A method that returns an ArrayList of Strings of names that have been getting more popular every decade.
  
• A method that returns an ArrayList of Strings of names that have been getting less popular every decade.
  
• implement a method of your own that checks for names that meet some criteria of your own design. You must thoroughly document what your criteria is in the method comments.

3. Complete the methods in the NameSurfer class and make changes to the menu to include the three options that are not yet present.

The menu choices are:

1 to search for names.
2 to display data for one name.
3 to display all names that appear in only one decade.
4 to display all names that appear in all decades.
5 to display all names that are more popular in every decade.
6 to display all names that are less popular in every decade.
7 to perform the method of your own design from your Names class
8 to quit

For expected program behavior review the sample run log. Your output shall match that of the sample run log for the various operations, except that you will not trim the output for operations that results in a large number of names and your output will include the description of the search you developed. (Show them all!)

4. Neat searches. This is an interesting application because when your program is finished you can investigate various trends in naming children. In a comment at the top of the file discuss one interesting trend you found. Here are some examples. (You may not use these as your interesting trend.)

• Why is Rock popular in the 50s and Trinity in 2000?
• Type in your grandparents names. Names like Mildred, Clem, Earl, and Clarence sound old fashioned and they are. But wait long enough and some names stage a come back. Emma. Hannah. Isabelle. Anna.
• Try historical names like Sigmund, Adolf, and Ike. What about variations such as Adolph?
• Why are some letters listed as names. A? M? J? (In a more recent version of the database single letter names are not inlcuded.)

The purposes of this assignment are

1. to work with ArrayLists
2. to implement a program that uses multiple classes. (object based programming, encapsulation)
3. to practice processing input
4. to practice implementing individual classes based on a given specification

You must complete this assignment on your own. You may not acquire from another person or the internet a partial or complete solution to this assignment. You may not show another student your solution to an assignment. You may not have another person (other than the instructor, TAs, or proctors) walk you through the solution. You may only discuss general ideas and approaches with other students but you may not develop code together.

You will submit the file NameSurfer.java. It will have the classes - NameSurfer, NameRecord, and Names. We will be looking at good documentation, design, and adherence to the coding convention mentioned below. Here is the initial structure of your program. Your code must have the following header:

/*  
  File: NameSurfer.java  

  Description:  

  Student Name:  

  Student UT EID:  

  Course Name: CS 312

  Unique Number:

  Date Created:

  Date Last Modified:

*/

You will follow the standard Java Coding Conventions. You can either view the HTML page or download the PDF or Postscript and print it out. There is a modification that I would like to make to the standard coding conventions. Please align the opening and closing braces vertically so that you can easily make out the blocks of code. For example:

Do this:
if ( x > 5 )
{
  a = b + c;
}

Not this:
if ( x > 5 ) {
  a = b + c;
}

Use the turnin program to submit your NameSurfer.java file. The TAs should receive your work by 11 PM on Saturday 19 November 2011. There will be substantial penalties if you do not adhere to the guidelines. The TA in charge of this assignment will be Sarah Abraham (theshark@cs.utexas.edu).

• You must work on this assignment individually.
• You must submit the .java file and not the .class file.
• Your .java file should have the header with the proper documentation.
• You should be submitting your .java file through the web based turnin program. We will not accept files e-mailed to us.
• You must complete the NameRecord and Names classes.
• You must include tests of the NameRecord class in the NameSurfer class.
• You must Use an ArrayList of Integers to store the ranks in the NameRecord class and an ArrayList of NameRecords in the Names class to store all the data?
• Compile and run your code on the command line.
• Your code must compile before submission.
• Here is the Grading Criteria.

This assignment is based on an assignment created by Nick Parlante and Stuart Reges and modified by Mike Scott. Nick Parlante got the idea for this assignment from an article by Peggy Orenstein in the New York Times, Where have all the Lisas Gone?