In this lab we will look at Java's built-in, and somewhat primative, I/O operations and how they must be used with Java's exception handling mechanism.
Download the starter Java archive
and save it into the
Now unjar the Java archive.
give you a directory csci/201/IOExcept
with two files IOExcept.java and
The Java code you use to start this lab is contained in IOExcept.java. You're going to write a program to process the data contained in the file iolabin.txt.
Go ahead and look at iolabin.txt. It's just a simple text file with four lines.
201 202 R2D2 333
Now let's return to IOExcept.java.
Using Java I/O isn't easy. Take a careful look at the
code within the
main method of
The first two Java statements create a
referenced by the variable
Because the File object is a representation of
a file name, rather than of a file, there is no problem in
executing these two statements even when iolabin.txt
does not exist.
String inName = "iolabin.txt" ; File inFile = new File(inName) ;
Now look at the three lines of Java code inside the
InputStream inStream = new FileInputStream(inFile) ; InputStreamReader inReader = new InputStreamReader(inStream) ; BufferedReader inLineIO = new BufferedReader(inReader) ;
The first line opens the
file referenced by
inFile and creates an associated
InputStream object named
inStream. If the file does not
will throw FileNotFoundException and the
remainder of the
try block will be skipped.
By the way, because
FileInputStream is a subclass of
InputStream, it is acceptable to assign a
FileInputStream object to an
InputStream is a simple sequence of
bytes, eight-bit numbers. A few years
ago it was OK to consider characters
as bytes interpreted under the good ole
ASCII (American Standard Code for Information Interchange) standard;
but today our programs are supposed to
be able to process the characters of French, Chinese,
Consequently, we can no longer consider a byte
to be a character. (Even in the old days, there
was also the problem that bytes were eight bits and ASCII characters
were seven bits, but that didn't seem to bother anyone.)
The second line of Java within the
creates a InputStreamReader object, or a sequence
of characters, from a
But we're still not there. We want to read our file one line at a time.
The third Java statement
creates a BufferedReader object, which can handle lines of
text, from the
By now, you probably appreciate why some introductory Java textbooks introduce a non-standard Keyboard class so that students are protected from naked Java I/O.
Finally, we get to a
while loop that reads and then
prints lines from the file. Notice, the read-then-test
style of programming required to make sure the loop terminates
after the last line of text is read. When this happens the
readLine method returns
and escapes the loop.
Now that you've studied the code, you should be convinced that it will read and print all the lines of the file. Go ahead and run the application.
It is quite possible that,
even though the file iolabin.txt clearly exists,
exception and your program printed the line:
No such file: iolabin.txt (No such file or directory)
This can happen because Java may be looking for iolabin.txt in some directory other than your csci/201/IOExcept directory. To correct this problem, you will need to set the working directory for your program. This isn't easy.
First, right-click on IOExcept.java within your Explorer window and then select Properties from the pull-down menu. This should raise a pop-up widow labeled Properties of IOExcept. Select the Execution tab at the bottom of this window.
Now, click on External Execution. Three dots will appear to the right of External Execution. Click on the dots. A pop-up labeled Executor should now appear. Select its Expert tab. Now press on the blank space, just to the right of Working Directory. It's another three dots.
Click on the three dots to bring up a window labeled
Working Directory. Now choose csci/201/IOExcept
as your working directory.
If you are successful, the Executor window should look something like this:
Now you should be able to run your program to produce the following output.
Line #1: 201 Line #2: 202 Line #3: R2D2 Line #4: 333
Right now the
while loop merely counts the number
of lines in iolabin.txt. Notice that most,
but not all, of the lines of iolabin.txt contain
single integers. In this lab you will be asked to add
all those integers and print their sum.
Your first challenge will be translating a Java
"201", into a Java
There is a
static Java method of
that will perform this operation for you; however, it must be
used with care for two reasons.
Integer.parseInt insists that the strings passed to it
contain only digits. No leading or trailing blanks are allowed.
Fortunately, there is a Java
called trim that will remove these blanks.
The second problem is a bit worse. When
is passed the string "
R2D2" it will throw the
To handle this problem
you must enclose your call to the
We are also going to ask you to write the sum of adding
all of these integers to the file iolabsum.txt.
To do this you must use the constructor for
FileOutputStream to open iolabsum.txt
as an OutputStream.
OutputStream may be used to
create a PrintStream. Fortunately,
println is a
PrintStream. By the way,
is also a
PrintStream, so you already know how to use one.
Your first task is to add up all the numbers in iolabin.txt
and print out their sum to
Your second, and final, task is to create a file called iolabsum.txt and print the sum to that file.