Topics
1. Introduction
Java® uses a stream-based approach to input and output. A stream in this context is a flow of data, which could either be read in from a data source (e.g. file, keyboard or socket) or written to a data sink (e.g file, screen, or socket). Java® currently supports two types of streams:
- 8-bit streams. These are intended for binary data i.e. data that will be manipulated at the byte level. The abstract base classes for 8-bit streams are InputStream and OutputStream.
- 16-bit streams. These are intended for character data. 16-bits streams are required becuase Java®'s internal representation for characters is the 16-bit Unicode format rather than the 8-bit ASCII format. The abstract base classes for 16-bit streams are Reader and Writer.
It is possible to create a 16-bit Reader from an 8-bit InputStream using the InputStreamReader class e.g.
Reader r = new InputStreamReader(System.in); // System.in is an example of an InputStream.
Likewise, it is possible to create a 16-bit Writer from an 8-bit OutputStream using the OutputStreamWriter class e.g.
Writer w = new OutputStreamWriter(System.out); // System.out is an example of an OutputStream.
2. Text Input
The FileReader class is used to read characters from a file. This class can only read one 16-bit Unicode character at a time (characters that are stored in 8-bit ASCII will be automatically promoted to Unicode.) In order to read a full line of text at once, we must layer a BufferedReader on top of the FileReader. Next, the individual words in the line of text can be extracted using a StringTokenizer. If the text contains numbers, we must also perform String to Number conversion operations, like Integer.parseInt() and Double.parseDouble().
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
try {
readText(args[0]);
}
catch (IOException e) {
e.printStackTrace();
}
}
// This function will read data from an ASCII text file.
public static void readText(String fileName) throws IOException {
// First create a FileReader. A Reader is a 16-bit input stream,
// which is intended for all forms of character (text) input.
Reader reader = new FileReader(fileName);
// Now create a BufferedReader from the Reader. This allows us to
// read in an entire line at a time.
BufferedReader bufferedReader = new BufferedReader(reader);
String nextLine;
while ((nextLine = bufferedReader.readLine()) != null) {
// Next, we create a StringTokenizer from the line we have just
// read in. This permits the extraction of nonspace characters.
StringTokenizer tokenizer = new StringTokenizer(nextLine);
// We can now extract various data types as follows.
String companyName = tokenizer.nextToken();
int numberShares = Integer.parseInt(tokenizer.nextToken());
double sharePrice = Double.parseDouble(tokenizer.nextToken());
// Print the data out on the screen.
System.out.print(companyName + " has " + numberShares);
System.out.println(" million shares valued at $" + sharePrice);
// Close the file.
bufferedReader.close();
}
}
}
This program can be easily converted to read in data from the keyboard. Simply replace
Reader reader = new FileReader(fileName);
with
Reader = new InputStreamReader(System.in);
3. Text Output
The FileWriter class is used to write text to a file. This class is only capable of writing out individual characters and strings. We can layer a PrintWriter on top of the FileWriter, so that we can write out numbers as well.
import java.io.*;
import java.util.*;
import java.text.*;
public class Main {
public static void main(String[] args) {
try {
writeText(args[0]);
}
catch (IOException e) {
e.printStackTrace();
}
}
// This function will write data to an ASCII text file.
public static void writeText(String fileName) throws IOException {
// First create a FileWriter. A Writer is a 16-bit output stream,
// which is intended for all forms of character (text) output.
Writer writer = new FileWriter(fileName);
// Next create a PrintWriter from the Writer. This allows us to
// print out other data types besides characters and Strings.
PrintWriter printWriter = new PrintWriter(writer);
// Now print out various data types.
boolean b = true;
int i = 20;
double d = 1.124;
String str = "This is some text.";
printWriter.print(b);
printWriter.print(i);
printWriter.print(d);
printWriter.println("\n" + str);
// This is an example of formatted output. In the format string,
// 0 and # represent digits. # means that the digit should not
// be displayed if it is 0.
DecimalFormat df = new DecimalFormat("#.000");
printWriter.println(df.format(200.0)); // 200.000
printWriter.println(df.format(0.123)); // .123
// This will flush the PrintWriter's internal buffer, causing the
// data to be actually written to file.
printWriter.flush();
// Finally, close the file.
printWriter.close();
}
}
4. Binary Input and Output
Binary input and output is done using the 8-bit streams. To read binary data from a file, we create a FileInputStream and then layer a DataInputStream on top of it. To write binary data to a file, we create a FileOutputStream and then layer a DataOutputStream on top of it. The following example illustrates this.
import java.io.*;
public class Main {
public static void main(String[] args) {
try {
writeBinary(args[0]);
readBinary(args[0]);
}
catch (IOException e) {
e.printStackTrace();
}
}
// This function will write binary data to a file.
public static void writeBinary(String fileName) throws IOException {
// First create a FileOutputStream.
OutputStream outputStream = new FileOutputStream(fileName);
// Now layer a DataOutputStream on top of it.
DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
// Now write out some data in binary format. Strings are written out
// in UTF format, which is a bridge between ASCII and Unicode.
int i = 5;
double d = 1.124;
char c = 'z';
String str = "Some text";
dataOutputStream.writeInt(i); // Increases file size by 4 bytes.
dataOutputStream.writeDouble(d); // Increases file size by 8 bytes.
dataOutputStream.writeChar(c); // Increases file size by 2 bytes.
dataOutputStream.writeUTF(str); // Increases file size by 2+9 bytes.
// Close the file.
dataOutputStream.close();
}
// This function will read binary data from a file.
public static void readBinary(String fileName) throws IOException {
// First create a FileInputStream.
InputStream inputStream = new FileInputStream(fileName);
// Now layer a DataInputStream on top of it.
DataInputStream dataInputStream = new DataInputStream(inputStream);
// Now read in data from the binary file.
int i;
double d;
char c;
String str;
i = dataInputStream.readInt();
d = dataInputStream.readDouble();
c = dataInputStream.readChar();
str = dataInputStream.readUTF();
System.out.print("integer " + i + " double " + d);
System.out.println(" char " + c + " String " + str);
// Close the file.
dataInputStream.close();
}
}