OBJECT ORIENTED PROGRAMMING II LECTURE 2 GEORGE KOUTSOGIANNAKIS CS 116 OBJECT ORIENTED PROGRAMMING II LECTURE 2 GEORGE KOUTSOGIANNAKIS Copyright: SPRING 2017 Illinois Institute of Technology/George Koutsogiannakis

OOP Review In previous lectures we discussed: User defined template classes Default constructor/ non default constructor(s). Accessor mutator methods. toString method. Equals method Other methods as required by the specification. Client classes How to use a static instance variable. Receiving inputs from user via command line and via the scanner object Note: You must bring your text to the lectures

OOP Review Today we want to review: Using the scanner object to read text files. Scope of variables within the class. Formatting Numbers.

Reading Text Files with Scanner Object We need the services of the java.io package and specifically two classes out of that package: File class IOException class Therefore we need to import those library classes import java.io.File; import java.io.IOException; Note: Alternatively one can import all the library classes out of package java.io by typing: import java.io.*;

Reading Text Files with Scanner Object Trying to open a file for reading (or writing) can cause problems (called exceptions) for various reasons of which some are: File does not exist. File name was misspelled File is corrupted. The part of the O.S. that finds files and opens them for reading and writing does not work. The java program we wrote has other problems. The java run time environment is corrupted Other reasons Therefore , we need to catch the exception ,if it happens, so that we don’t crash our program or the system.

Reading Text Files with Scanner Object Within the method that needs to open the file for reading write the following code: try { //code to open the file for reading and //capturing the read items goes here. } catch (IOException ioe) System.out.println(“Something went wrong”);

Reading Text Files with Scanner Object try and catch are keywords Inside the try block: try { File myfile = new File(“NameOfTextFile.txt”); Scanner scan= new Scanner(myfile); //The above code tells the system to find the file we are //looking for and associates the scanner object with that file. //Other code } catch (IOException ioe) System.out.println(“Error Occurred”);

Reading Text Files with Scanner Object Continue inside the try block by creating a loop that keeps reading data until there is no more data to be read. The scanner class has methods that allow us to read one String at a time or one line at a time (as one String). Look up the scanner class and its methods in the API.

Scanner Class hasNext Method This method detects the end of the input values one String at a time (one token). The hasNext method eliminates the need for a priming read because the method looks ahead for input. An IOException may be generated if we encounter problems reading the file. Java requires us to acknowledge that these exceptions may be generated. Note that there is another method called hasNextLine() which returns a boolean and can sense the end of data line by line. Return type Method name and argument list Boolean hasNext( ) returns true if there is more data to read; returns false when the end of the file is reached

Scanner Class hasNext… Methods Each method returns true if the next token in the input stream can be interpreted as the data type requested, and false otherwise. Return type Method name and argument list boolean hasNextInt( ) hasNextDouble( ) hasNextFloat( ) hasNextByte( ) hasNextShort( ) hasNextLong( ) hasNextBoolean( ) hasNext( )

Example Reading From File import java.io.File; import java.io.IOException; Import java.util.Scanner; public class ReadFile { public static void main(String[] args) { String str=“ “; int count=0; try { File myFile=new File(“text.txt”); Scanner scan=new Scanner(myFile); while(scan.hasNextLine()) str=scan.nextLine(); System.out. println(str); count++; // Note that if we want the individual Strings (tokens) inside each line, we need to use the StringTokenizer object to tokenize the line read during each iteration!!!! } } //end of try block of code!!!!!! catch(IOException ioe) { System.out.println(“The file can not be read”); } System.out.println(“The number of strings tokens read is:”+count);

StringTokenizer In the previous example we captured one line of data at a time, from the text file. The String str has the value of the entire line during each cycle in the while loop (its value changes to the next line during the next cycle). Now, we may be interested in the individual Strings that make up the entire line. Therefore when we capture the line we may want to break it up into individual tokens. To do that we would need to create another loop inside the loop while(scan.hasNextLine()). The reason for that is that we don’t know how many tokens are in one line (presumably the programmer does not know the content of the text file that his/her program is reading).

StringTokenizer Modifying the program for the StringTokenizer: First at the top we need to import the library package java.util which contains the StringTokenizer class. Then we modify the while loop as follows: while(scan.hasNextLine()) { str=scan.nextLine(); StringTokenizer strtok=new StringTokenizer(str, “,”); while(strtok.hasMoreTokens()) String tokenstr=strtok.nextToken(); //Now, do what you want with the String tokenstr. You may have to //parse it to another data type depending on what data type you expect. } System.out. println(str); count++;

StringTokenizer Look up the StringTokenizer class in the API NOW. Questions: What does the parameter count measure? What is the meaning of the “ , ” in the constructor of StringTokenizer? Can we have any delimiter? What about using space as a delimiter?

Class Scope In the previous example the String str was declared at the top of the main method. Therefore we say that the String str has method scope. That means that the value held by the identifier str can be seen anywhere from within the method. If, for example, we had declared str inside the while loop :

Class Scope while(scan.hasNextLine()) { String str=scan.nextLine(); System.out. println(str); count++; // Note that if we want the individual Strings (tokens) inside each line, we need to use the StringTokenizer object to tokenize the line read during each iteration!!!! } Then trying to access the value of str outside the while loop would had caused an error, because the variable’ s str scope is limited to the while loop in this case The same problem arises if we declared String str at the top of the try block and then try to access it outside the try block:

Class Scope try { String str=“ “; File myFile=new File(“text.txt”); Scanner scan=new Scanner(myFile); while(scan.hasNextLine()) str=scan.nextLine(); System.out. println(str); count++; // Note that if we want the individual Strings (tokens) inside each line, we need to use the StringTokenizer object to tokenize the line read during each iteration!!!! } Trying to access str outside the try block will cause an error. The scope of str is limited within the try block. Note that accessing str inside the while loop is O.K. because the while loop is part of the try block.

Class Scope What if we declared the String str outside the main method? public class ReadFile { String str=“ “; public static void main(String[] args) { int count=0; try { File myFile=new File(“text.txt”); Scanner scan=new Scanner(myFile); ……………………………………………… }// end of main method public static void anotherMethod() { } }//end of class

Class Scope Notice that in this case we have included another method in the class besides the main. Since the String str is declared outside any method but inside the class , we say that the variable str has class scope: That means that its value can be seen and it is accessible by any method in the class!!

Formatting Numbers In this lecture we would discuss only two types of formatting: Formatting a double data type to restrict the number of decimal points. Formatting a decimal number to convert it to a particular currency like US dollars. The first action is done with library class: DecimalFormat from package java.text (must import java.text.DecimalFormat)

Formatting Numbers Create an object of DecimalFormat and in the constructor define the pattern of decimal points as a String DecimalFormat df=new DecimalFormat(“0.00”); The object df can convert double data types to the accuracy of only two decimal points in this example pattern. Suppose we have the decimal data type double mydoubletype The code below converts the data type mydoubletype into a new data type of double type but with a precision of only two decimal points: double newdoubletype= df.format(mydoubletype);

Formatting Numbers The conversion to currency is done with library class NumberFormat of package java.text (import java.text.NumberFormat;) For US dollars: create an object like this: NumberFormat form=NumberFormat.getCurrencyInstance(); Use the object form as follows: String strversionofdouble=form.format(mydoublenumber); Notice that the double number held by identifier mydouublenumber is converted into two decimal points and the $ sign is placed in front of it. It then it gets assigned to a String type. If we want the String strversionofdouble converted back to a double we need to parse it