CSCI 1103 Lab12: Input with Scanner

• Download the code distribution every lab
• See further setup instructions below

Empty

Reading data from stored files is an essential skill. Reading from arbitrary sources such as the user, a string, or a network location usually follows a similar pattern to reading from files. Completing this lab will illustrate how Java's Scanner class provides a uniform mechanism to read from a variety of sources. To complete the lab, one must understand several key elements surrounding Scanner input:

• How to notify the compiler that a Scanner will be used in your code by using an import statement
• How to create a Scanner which reads from a String and from a File existing on disk
• Which methods Scanner provides to read tokens from the input stream. For example, find out which method reads a single word as a string and which method reads a number as an integer.
• Which methods Scanner provides to check if a particular type of token appears next in the input stream, for example if the next token is a real number.
• How to determine if there is any input left in the input stream.

Processing data also requires mastery of basic programming concepts such as iteration, conditional execution, and function declaration which will be reinforced here. Finally, this lab illustrates how one central function can facilitate a variety of tasks by writing short functions that pass the central function appropriate arguments.

As in Lab01, download the code pack linked at the top of the page. Unzip this which will create a folder and create your files in that folder.

Create a class called ScannerPractice in a file called ScannerPractice.java which you will need to create. This class will contain several methods which will be tested. You may want to copy the skeleton of the class (found below) into your file to get started but know that you'll need to add method bodies to get the skeleton to compile. You may add a main() method and use it for testing your own functions and additionally any other helper functions you might find useful. Just make sure that all the required methods are present.

DrJava's interactive loop is also useful for quick, by-hand testing. The examples below illustrate this.

The ScannerPractice class at a minimum must have the following class structure.

public class ScannerPractice{
// Contains some simple parsing functions for reading from Scanners,
// Strings, and Files.
//
// Don't forget to import the Scanner and File classes at the top of
// the file.

  public static double sumReals(Scanner input);
  // Accept a Scanner argument and read space-separated words from
  // it. If a word is a valid real number such as 0.1 or -3.14159 or
  // 87 then add the number onto a running total.  When there is no
  // more input available in the scanner, return the total.

  public static double sumReals(String parseString);
  // Perform the same computation as sumReals(Scanner) except parse
  // the given string for real numbers.  You will need to create a new
  // Scanner which reads from parameter String.  It may be useful to
  // use employ sumReals(Scanner) in this function.

  public static double sumRealsInFile(String filename) throws Exception;
  // Perform the same computation as sumReals(Scanner) except read
  // from the file named by the parameter filename.  The actual file
  // with the text should already be stored on disk. Some sample files
  // are stored in wordsNnumbers1.txt and wordsNnumbers2.txt.  This
  // function may throw an exception if the named file does not
  // exist. It may be useful to use the function sumReals(Scanner).

  public static String [] readNamesFromFile(String filename);
  // Read a names from a file and return an array of the names.  Names
  // are stored one per line but may contain multiple parts and spaces
  // in them such as the following:
  //
  // Luke Cage
  // Jessica Jones
  // Matt Murdock
  // Danny Iron Fist Rand
  // Elektra Nachios
  // Alexandra
  // Madame Gao
  // Wilson Grant Fisk
  // 
  // Use two passes through the file. Count lines first, then allocate
  // an array, then read lines into the array. Put all operations in a
  // try/catch block. If an exception results, throw a new runtime
  // exception.

}

While there are 4 problems in the lab, it should be no longer than previous labs. Problem 1 requires getting acquainted with the Scanner class but once this is done, Problems 2 and 3 are made very short by leveraging the method defined in Problem 1. Problem 4 builds takes a different tack as it requires reading through a file and returning its contents as an array of Strings.

The ScannerPractice class uses some classes from the Java library which are not available by default. Instead they must be explicitly imported. Make sure to include the following at the top of your file.

import java.util.Scanner;
import java.io.File;

This will make the Scanner and File classes available in the rest of the class. Should errors along these lines appear:

ScannerPractice.java:15: error: cannot find symbol
  public static double sumReals(Scanner input){
                                ^
  symbol:   class Scanner
  location: class ScannerPractice

it is likely an import will fix them.

public static double sumReals(Scanner input)

This method takes an already open Scanner and proceeds to read input words from it. If any input word happens to represent a valid real number, it is added to a running total. When no input remains in the Scanner, this running total is returned. If no words are valid real numbers then 0.0 should be returned. Some example uses in DrJava's interactive loop are shown below.

Welcome to DrJava.  
> import java.util.Scanner;

// All numbers
> String allNums = "1.23 4.56 7.89";
> Scanner in = new Scanner(allNums);
> double total = ScannerPractice.sumReals(in);
> total
13.68
 
// All words
> String allWords = "none of these are numbers";
> in = new Scanner(allWords);
> ScannerPractice.sumReals(in)
0.0

// Mixed words and real numbers
> String mixed = "number 1.0    two  12.3   stuffed turkey -0.99   five";
> in = new Scanner(mixed);
> ScannerPractice.sumReals(in)
12.31

Constraint: Do not use regular expressions to solve this problem. They are not needed and will only over-complicate a good solution. Instead, focus on the built-in ability of Scanner to recognize different kinds of input and distinguish when a number can be read next or if the next token is an arbitrary string.

public static double sumReals(String parseString)

Rather than take an already opened Scanner this method takes a String to parse. It should create a Scanner object that reads from the parameter String and then perform the same computation as sumReals(Scanner).

Note that this illustrates that Java methods may have the same name so long as they have different argument types or different numbers of arguments.

Some sample uses

> ScannerPractice.sumReals("here are some numbers... psyche!")
0.0
> ScannerPractice.sumReals("43110")
43110.0
> ScannerPractice.sumReals("4.3 110.5  0.12  3.14")
118.06
> ScannerPractice.sumReals("one 1.0 two 2.0 thre-and-a-half 3.5 and so on...  ")
6.5

Hint: It is tempting to copy and paste code for similar methods but clever programmers figure out how to use an already written function to solve a new problem by passing the old function appropriately constructed arguments. The best solutions to this problem are 1-2 lines long.

public static double sumRealsInFile(String filename) throws Exception

This function opens a pre-existing file on disk, reads it word by word and sums any valid real numbers that appear in it. Some example files are present with the code distribution called wordsNumbers1.txt and wordsNumbers2.txt. Examples of summing reals in these files are as follows.

> ScannerPractice.sumRealsInFile("wordsNumbers1.txt")
15.912099999999999
> ScannerPractice.sumRealsInFile("wordsNumbers2.txt")
-12.3

Hint: The best solutions to this problem are 1-2 lines long and make use of another function you wrote.

Notice that the type signature for the method includes throws Exception. In Java, some operations can go wrong which triggers an exception. Methods that can cause certain kinds of exceptions must "admit" this fact by declaring that they can throw some kind of exception. In this case, creating a Scanner that reads from a file may encounter difficulties. For instance, if the requested file is not present, then an exception will be raised. For now, we will simply state an arbitrary Exception may be thrown but in the near future we will write more refined java which declares the specific kinds of exceptions that can be thrown, in this case a FileNotFoundException.

Note - only "checked" exceptions must have these throws annotations added; RuntimeException and Error types and their descendents are unchecked, and all others are checked. Most exceptions you experience will be either a RuntimeException (unchecked) or an IOException (checked), as we see here.

public static String [] readNamesFromFile(String filename)

This method reads all names from a file and returns an array filled with the names. Files with names in them look like the following.

File names1.txt

Nicole
Tyler
Devon

File names2.txt

Luke Cage
Jessica Jones
Matt Murdock
Danny Iron Fist Rand
Elektra Nachios
Alexandra
Madame Gao
Wilson Grant Fisk

Interactive demonstrations of the method are as follows.

Welcome to DrJava.
> String tas[] = ScannerPractice.readNamesFromFile("names1.txt");
> tas
{ Nicole, Tyler, Devon }
> tas.length
3
> String marvel[] = ScannerPractice.readNamesFromFile("names2.txt");
> marvel
{ Luke Cage, Jessica Jones, Matt Murdock, Danny Iron Fist Rand, Elektra Nachios, Alexandra, Madame Gao, Wilson Grant Fisk }
> marvel.length
8

Notice that names appear on a single line but may contain spaces such as Luke Cage or Wilson Grant Fisk. Also, notice that it is not known ahead of time how many names are in the file. Finally, notice that the type signature of the method does not involve any exceptions. All these problems must be surmounted to complete this problem.