Stanford CS106A NameSurfer Solution

25 Nov

I am really really excited that I was able to get through the Stanford CS106A class so far. Only one assignment left!!!! And I’m extremely excited that I actually like programming (I probably wouldn’t have come this far if I didn’t).

Anyway, without more interruptions, here is the solution to the NameSurfer class. If you’re interested in the different parts of this solution, make sure to check out:

You can also find the full code on github.


Here is my solution to the NameSurfer Class, which pulls the whole program together.

NameSurfer.java

/*
 * File: NameSurfer.java
 * ---------------------
 * When it is finished, this program will implements the viewer for
 * the baby-name database described in the assignment handout.
 */

import acm.program.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
import java.util.*;
import acm.util.*;

public class NameSurfer extends Program implements NameSurferConstants {

	/* Private instance variables*/
	private JLabel label;
	private JTextField Name;
	private JButton Graph;
	private JButton Clear;
	private NameSurferDataBase namesdb;
	private NameSurferGraph graph;

/* Method: init() */
/**
 * This method has the responsibility for reading in the data base
 * and initializing the interactors at the bottom of the window.
 */
	public void init() {

		//Set up initial display with ineractors and canvas
		label = new JLabel("Name ");
		add(label, SOUTH);

		Name = new JTextField(20);
		add(Name, SOUTH);
		Name.addActionListener(this);

		Graph = new JButton("Graph");
		add(Graph, SOUTH);

		Clear = new JButton("Clear");
		add(Clear, SOUTH);

		graph = new NameSurferGraph();
		add(graph);

		addActionListeners();

		//reads the file of names and adds to the NameSurferDataBase
		namesdb = new NameSurferDataBase(NAMES_DATA_FILE);
	}

/* Method: actionPerformed(e) */
/**
 * This class is responsible for detecting when the buttons are
 * clicked, so you will have to define a method to respond to
 * button actions.
 */
	public void actionPerformed(ActionEvent e) {
		if(e.getActionCommand().equals("Clear")) {
			graph.clear();
			graph.update();
		}
		else {
			String enteredName = Name.getText();
			NameSurferEntry rankings = namesdb.findEntry(enteredName);
			if(rankings != null) {
				graph.addEntry(rankings);
				graph.update();
			}
		}
	}
}

NameSurferDataBase.java

mport java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
import acm.util.*;
import java.util.*;

/*
 * File: NameSurferDataBase.java
 * -----------------------------
 * This class keeps track of the complete database of names.
 * The constructor reads in the database from a file, and
 * the only public method makes it possible to look up a
 * name and get back the corresponding NameSurferEntry.
 * Names are matched independent of case, so that "Eric"
 * and "ERIC" are the same names.
 */

public class NameSurferDataBase implements NameSurferConstants {

	/* Private instance variables */
	private Map  namesdb = new HashMap ();

/* Constructor: NameSurferDataBase(filename) */
/**
 * Creates a new NameSurferDataBase and initializes it using the
 * data in the specified file.  The constructor throws an error
 * exception if the requested file does not exist or if an error
 * occurs as the file is being read.
 */
	public NameSurferDataBase(String filename) {
		getNameData(filename);
	}

	private void getNameData(String filename) {
		try{
			BufferedReader rd = new BufferedReader(new FileReader(filename));
			while(true) {
				String line = rd.readLine();
				if(line == null) break;
				NameSurferEntry nameEntry = new NameSurferEntry(line);
				namesdb.put(nameEntry.getName(), nameEntry);
			}
			rd.close();
		} catch(IOException ex) {
				throw new ErrorException(ex);
			}
		}

/* Method: findEntry(name) */
/**
 * Returns the NameSurferEntry associated with this name, if one
 * exists.  If the name does not appear in the database, this
 * method returns null.
 */
	public NameSurferEntry findEntry(String name) {
		char ch = name.charAt(0);
		if(Character.isLowerCase(ch) == true) {
			ch = Character.toUpperCase(ch);
		}
		String otherLetters = name.substring(1);
		otherLetters = otherLetters.toLowerCase();
		name = ch + otherLetters;
		if(namesdb.containsKey(name)) {
			return namesdb.get(name);
		}
		else{
			return null;
		}
	}

}

NameSurferEntry.java

/*
 * File: NameSurferEntry.java
 * --------------------------
 * This class represents a single entry in the database.  Each
 * NameSurferEntry contains a name and a list giving the popularity
 * of that name for each decade stretching back to 1900.
 */

import acm.util.*;
import java.util.*;

public class NameSurferEntry implements NameSurferConstants {

	/*private instance variables*/
	private String Name;
	private int[] rankings = new int[NDECADES];
	
	
/* Constructor: NameSurferEntry(line) */
/**
 * Creates a new NameSurferEntry from a data line as it appears
 * in the data file.  Each line begins with the name, which is
 * followed by integers giving the rank of that name for each
 * decade.
 */
	public NameSurferEntry(String line) {
		parseLine(line);
	}
	
	private void parseLine(String line) {
		//gets the name
		int nameEnd = line.indexOf(" ");
		Name = line.substring(0, nameEnd);
	
		//gets the popularity ranking and puts it into an array
		String numbers = line.substring(nameEnd + 1);
		StringTokenizer tokenizer = new StringTokenizer(numbers);
		for(int count = 0; tokenizer.hasMoreTokens(); count++) {
			int popularityRank = Integer.parseInt(tokenizer.nextToken());
			rankings[count] = popularityRank;
		}
	}

/* Method: getName() */
/**
 * Returns the name associated with this entry.
 */
	public String getName() {
		return Name;
		}

/* Method: getRank(decade) */
/**
 * Returns the rank associated with an entry for a particular
 * decade.  The decade value is an integer indicating how many
 * decades have passed since the first year in the database,
 * which is given by the constant START_DECADE.  If a name does
 * not appear in a decade, the rank value is 0.
 */
	public int getRank(int decade) {
		return rankings[decade];
	}

/* Method: toString() */
/**
 * Returns a string that makes it easy to see the value of a
 * NameSurferEntry.
 */
	public String toString() {
		String value = "\"" + Name + " [";
		for(int i = 0; i<NDECADES; i++) {
			value += getRank(i) + " ";
		}
		value += "]\"";
		return value;
	}
}

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s