Reading and writing

Exception handling

• Some method calls are inherently problematic; they can lead to unexpected problems, exceptions. In these cases, Java forces the programmer to "catch" the exceptions.
• Opening a file for reading or writing is a case where an exception can easily occur because the user may not have read or write permission in the directory where the file is, for example. Reading from an opened file is another such case because someone could move or delete the file between the time it is opened and the time the program reads from it.
• Exceptions are caught like this:
  try {
  < statements including ones where exceptions might occur >
  }
  catch (<exception type> <exception identifier>) {
  < statements specifying what to do when an exception is caught >
  }
  See the example below.

Writing to a file

• Note first that all built-in Java classes that have to do with reading and writing are in the java.io package, so you have to do something like
  import java.io.*
  in the files where you will use these classes.
• To write to a file, the program must open an output stream to the file and create a writer which writes to that stream. Here is one convenient way to do this:
  new PrintWriter(new FileWriter(<filename>, <append?>));
  where filename is a String, and append? is a boolean specifying whether the program is going to append text to what is already in the file (if it exists) as opposed to overwrite what is already there. Note that this code doesn't explicitly create the output stream; this is handled by the FileWriter class.
• Possible exceptions must be caught for this code. Here is an example of how this might appear in a method definition.
  private void makeWriter() {
    try {
      System.out.println("Opening output file " + FILENAME);
      outputWriter = new PrintWriter(new FileWriter(FILENAME, true));
     } catch(IOException e) {
      System.err.println("MyCanvas: makeWriter: " + e + ".");
     }
  }
• To write to the file, you just call one of the write methods in PrintWriter or its ancestor classes, for example:
  outputWriter.println("Hello there.");
  where outputWriter is a variable bound to a PrintWriter.
• The stream must be closed when the program is finished writing to the file. This can be accomplished with the Writer method close, which takes no parameters.

Reading from a file

• As with writing, reading requires a stream and a reader to read from the stream. This is one way to accomplish it:
  new InputStreamReader(new FileInputStream(<filename>));
• In addition, to simplify reading from the file, we can create a tokenizer, an instance of the class StreamTokenizer. The tokenizer reads individual words or numbers from the file one at a time. You can create a tokenizer like this:
  new StreamTokenizer(<reader>);
  where reader is an instance of the class InputStreamReader (see above).
• StreamTokenizer has one method you'll need, nextToken, which takes no parameters. This grabs the next token from the file.
• After you have called nextToken, you can examine the token using one of three tokenizer member variables: ttype, sval, and nval.
  • ttype returns the type of the current token. This is an int, equal to one of the following: StreamTokenizer.TT_WORD, StreamTokenizer.TT_NUMBER, or StreamTokenizer.TT_EOF The last indicates that the tokenizer has reached the end of the file.
  • To access the value of the current token, use sval if it is a String and nval if it is a number. Note that nval is a double (even if what appear in the file are integers), so you will need to cast it to an int if that is what you need.
• The code that opens the input stream and tokenizer and that gets a new token has to be in an exception-handling try block. As with writing, you can use the general exception type IOException in the catch block.
• As with output streams, input streams need to be closed when you are done with them. You can do by calling the InputStreamReader method close on the stream.

© 2004. Indiana University and Michael Gasser. www.indiana.edu/~gasser/Q530/Notes/readwrite.html 15 Nov 2004