IO Streams
COMP 180
IO
The simplest way to do IO: the scanner class
Very flexible and easy to use.
Can read from the console or from a file
The scanner class
Example
import java.util.*;
import java.io.File;
import java.io.FileNotFoundException;
public class scanIn {
public static void main(String[] args) {
String first, last;
int ssn;
try{
Scanner sc = new Scanner(new File("input.txt"));
while (sc.hasNext()) {
first = sc.next();
last = sc.next();
ssn = sc.nextInt();
System.out.println("First: " + first + "\nLast: " + last + "\nSSN: " + ssn);
}
}catch (FileNotFoundException e){
System.out.println(e);
} //end catch
} //end main
} // end class
Streams
A stream is a ordered sequence of bytes that can be used as
A source for input (input stream)
A destination for output (output stream)
A program can have multiple streams
Examples: console, files, sockets, memory, strings
The java classes in the package java.io provide utilities for
dealing with streams
Streams
Java categorizes streams in multiple ways:
input or output
character (16-bit unicode characters) or byte (8 bits)
data or processing (manipulates the stream data)
Streams
To read data, a JAVA program opens a stream on a source
(such as a file, memory, or a socket) It then reads the
information sequentially
To send information to an external destination, the program
opens a stream to the destination and writes the data
sequentially to the stream
Java has predefined byte streams:
System.in
System.out
System.err
Byte Streams
InputStream and OutputStream
Abstract classes
The parent class of all byte streams
Defines the methods common to all byte streams
object
InputStream
OutputStream
FileInputStream
FileOutputStream
ByteArrayInputStream ByteArrayOutputStream
PipedInputStream
PipedOutputStream
ByteStreams: example
import java.io.*;
class CountBytes {
public static void main(String[] args)
throws IOException
{
InputStream in;
if (args.length == 0)
in = System.in;
else
in = new FileInputStream(args[0]);
int total = 0;
while (in.read() != -1)
total++;
System.out.println(total + “ bytes”);
}
}
Character Streams
Reader and Writer streams
Abstract classes
The parent class of all character streams
Defines the methods common to all character streams
These methods correspond to
InputStream/OutputStream methods
Example:
Read method of InputStream returns lowest 8 bits
of an int as a byte
Read method of Reader returns lowest 16 bits of an
int as a char
Character Streams
Reader and Writer
object
Reader
Writer
InputStreamReader
OutputStreamWriter
CharArrayReader CharArrayWriter
BufferedReader
BufferedWriter
Character Streams: Example
import java.io.*;
class CountSpace {
public static void main(String[] args)
throws IOException
{
Reader in;
if (args.length == 0)
in = new InputStreamReader(System.in);
else
in = new FileReader(args[0]);
int ch;
int total;
int spaces = 0;
for (total = 0; (ch = in.read()) != -1; total++) {
if (Character.isWhitespace((char) ch))
spaces++;
}
System.out.println(total + “ chars, “ + spaces + “ spaces”);
}
}
Example: Console I/O
To read from the console (System.in) you need to be able to
read characters.
You can change the byte stream to a character stream
InputStreamReader charReader = new InputStreamReader(System.in);
This will read each individual character. To get tokens*, turn
the input stream into a BufferedReader object:
BufferedReader consoleReader = new BufferedReader(charReader);
* a token is a set of characters surrounded by white space
Example: Console I/O
Now use the readLine() method of BufferedReader to read
a line from the console (a string):
String input = consoleReader.readLine();
In this case, the token is the entire line – the linefeed character
is used to determine when to stop putting characters into the
buffer.
To change a String into a number:
int count = Integer.parseInt(input); // there is also a Double
Note: System.out is predefined to print numbers and strings.
File IO example
// you must have these import statements at the top of the file:
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
1. You must create a file
object to represent the
BufferedReader fileIO = null; file.
StreamTokenizer tokenizer; 2. You can then turn the
File inputFile = new File("pay.txt"); //the input file File object into a
//create a buffered stream to read from the file FileReader. FileReader
turns bytes into unicode
try {
characters
FileReader fileStream = new FileReader(inputFile);
// or just: FileReader fileStream = new FileReader(“pay.txt”);
BufferedReader fileIO = new BufferedReader(fileStream);
} 3. A BufferedReader will let you read in lines of
catch(FileNotFoundException err) { characters.
System.out.println(err);
Opening a file throws a FileNotFoundException. You
System.exit(-1); // exit if file not found
must catch it!
}
The rest of this example is given in a later slide.
Tokenizer
One often wants to read entire words or numbers from a
stream
Without having to put one datum per line
Using a delimiter other than new line
To assist in reading meaningful aggregates of data from a
stream, JAVA provides Tokenizers
StreamTokenizer class reads tokens from a stream
StringTokenizer extracts tokens from a String that has
been read into memory
Creating a tokenizer on a file stream
1. Create a tokenizer on the file’s BufferedReader
2. While there is still data
1. Get the next token
2. Translate the token into the appropriate data type
3. Use the data
4. continue
Tokenizers
How streamTokenizer works:
First create a new token stream:
StreamTokenizer tokenizer;
tokenizer = new StreamTokenizer(fileIO);
Next use the streamTokenizer method nextToken( )to get the next
token from the stream
Returns the token type not the actual value
nextToken = tokenizer.nextToken();
Now you can get the value of the token using
String name = tokenizer.sval; // sval is value of the next token as a string
double hours = tokenizer.nval; // nval is the value of the next token as a number
Tokenizers
Note: you must catch the IOException when getting tokens:
try {
nextToken = tokenizer.nextToken(); //get the first token
while (nextToken != StreamTokenizer.TT_EOF) {
// … more code here
} //while
}//try
catch (IOException err) {
// this code executes if there is an error in getting the next token
System.out.println(err);
}//catch
Tokenizers
Tokenizer returns the type of the token.
Tokenizer classes provide flags (as static properties)
Class constants that are set when the token is retrieved
Provide information about the token
Examples:
TT_EOF
TT_EOL
TT_WORD
TT_NUMBER
These last two allow you to determine the data type of the
token before converting it if you don’t know what type you
are expecting – or to do error checking.
File IO example with tokens
// This is from the previous example
BufferedReader fileIO = null;
StreamTokenizer tokenizer;
File inputFile = new File("pay.txt"); //the input file
//create a buffered stream to read from the file
try {
FileReader fileStream = new FileReader(inputFile);
fileIO = new BufferedReader(fileStream);
}
catch(FileNotFoundException err) {
System.out.println(err);
System.exit(-1); // exit if file not found
}
// now we tokenize that stream
int nextToken;
double hours, rate;
String name;
tokenizer = new StreamTokenizer(fileIO);
try {
//this will cause the stream to get the next token. It does NOT return
//the actual token, but returns a code that indicates what type was read
nextToken = tokenizer.nextToken(); //get the first token
//we know the data types we are reading
while (nextToken != StreamTokenizer.TT_EOF) {
name = tokenizer.sval; //name is a string
nextToken = tokenizer.nextToken();
hours = tokenizer.nval; //hours is a number
nextToken = tokenizer.nextToken();
rate = tokenizer.nval; //rate is a number
//get the next token
nextToken = tokenizer.nextToken();
} //while
}//try
catch (IOException err) {
// this code executes if there is an error in getting the next token from
the file
System.out.println(err);
}//catch
Console IO example with tokens
// example of tokenizing the console (from fileIOmain.java)
BufferedInputStream consoleIO = new BufferedInputStream(System.in);
//now create a tokenizer on the buffered stream to read tokens
StreamTokenizer tokenizer = new StreamTokenizer(consoleIO);
tokenizer.eolIsSignificant(true); // tell tokenizer to recognize end-of-line
System.out.println("Enter a line of input: ");
while(!done ) {// get each successive token until an oel is seen
try {
nextToken = tokenizer.nextToken(); //get the token
if (nextToken == StreamTokenizer.TT_EOL) // is it an eol?
done = true;
else if (nextToken == StreamTokenizer.TT_WORD) { //is it a word
stringToken = tokenizer.sval; //convert to string
System.out.println("the token is " + stringToken);
}
else if (nextToken == StreamTokenizer.TT_NUMBER) { //is it a number
numberToken = tokenizer.nval; //convert to double
System.out.println("the token is " + numberToken);
}
} //try create tokenizer
catch (IOException err) {
System.out.println("IOException reading from consoleIO");
} //catch
} //while
