Upload
martin-strickland
View
237
Download
0
Embed Size (px)
Citation preview
Input and Output Stream Classes Processing External Files Data Streams Print Streams Buffered Streams Text Input and Output on the Console
Object Streams
Streams A stream is an abstraction of the continuous one-way
flow of data.
Program
Output Stream
File
Input Stream
Stream Classes The stream classes can be categorized into two types:
byte streams and character streams.
a) The InputStream/OutputStream class is theroot of all byte stream classes.
b) The Reader/Writer class is the root of all character stream classes.
The subclasses of InputStream/ OutputStream are analogous to the subclasses of Reader/Writer. In all, over 40 classes are used to provide input and
output.
A) Byte Stream Classes
InputStream
OutputStream
RandomAccessFile
Object
PipedOutputStream
SequenceInputStream
StringBufferInputStream
ByteArrayOutputStream
ObjectOutputStream
FilterOutputStream
FileOutputStream
PipedInputStream
PushBackInputStream
BufferedInputStream
LineNumberInputStream
DataInputStream
BufferedOutputStream
DataOutputStream
PrintStream
ObjectInputStream
FilterInputStream
FileInputStream
ByteArrayInputStreamDataInput
DataOutput
ObjectOutput
ObjectInput
B) Character Stream Classes
Reader
Writer
StreamTokenizer
Object
PrintWriter
BufferedWriter
CharArrayWriter
PipedWriter
FilterWriter
PipedReader
LineNumberReader
FileReader
PushBackReader
FileWriter
StringWriter
StringReader
InputStreamReader
CharArrayReader
BufferedReader
FilterReader
OutputStreamWriter
Abstract InputStream Class abstract int read() throws IOException
read the next byte and returns its value, an int in range 0-255; at the end returns -1.
int read(byte[] b) throws IOException
Read up to b.length bytes into array b, returns b.length or the number of bytes read, or returns -1 at the end of the stream.
void close() throws IOException
int available() throws IOException
Returns the number of bytes that can be read form the input stream.
long skip(long n) throws IOException
Skip over and discard n bytes of data from the input stream.
Abstract Reader Class
The Reader class is similar to the InputStream class. The methods in Reader are subject to character interpretation.
abstract int read() throws IOException
int read(char b[]) throws IOException
void close() throws IOException
void skip(long n) throws IOException
Abstract OutputStream Class
abstract void write(int b) throws IOException
void write(byte[] b) throws IOException
void close() throws IOException
void flush() throws IOException
Abstract Writer Class
abstract void write(char b) throws IOException
void write(char[] b) throws IOException
void close() throws IOException
void flush() throws IOException
The File Class The File class is a wrapper class for the file name.
The File class does not tell us how to read or write
information in files.
The File class is used to check properties of files,
such as whether the file exists, or is readable, or is
updateable.
The File Class The statement creates a File object:
File MyFile = new File(“C:\myData\in.data”); Methods String getName(); String getPath(); // Get full path of the file String getAbsolutePath(); String getParent(); // // Get the directory that contains the file int getLength(); boolean exists(); boolean canWrite(); boolean canRead(); boolean isDirectory(); boolean isFile(); boolean delete();
Processing External Files
You must use file streams to read from or writeto a disk file.
You can use FileInputStream or
FileOutputStream for byte streams.You can use FileReader or FileWriter for character streams.
File I/O Stream ConstructorsConstructing instances of FileInputStream, FileOutputStream, FileReader, and FileWriter from file names: public FileInputStream(String filenameString);
public FileInputStream(File file);
public FileOutputStream(String filenameString);
public FileOutputStream(File file);
public FileReader(String filenameString);
public FileReader(File file);
public FileWriter(String filenameString);
public FileWriter(File file);
Example of File I/O Stream Constructors
FileInputStream infile = new FileInputStream("in.dat");
FileInputStream infile = new FileInputStream(file);
FileOutputStream outfile = new FileInputStream("in.dat");
FileOutputStream outfile = new FileInputStream(file);
FileReader infile = new FileReader("in.dat");
FileReader infile = new FileRader(file);
FileWriter outfile = new FileWriter("in.dat");
FileWriter outfile = new FileWriter(file);
ExampleProcessing External Files
Example: Copy External Filesimport java.io.*;public class CopyFile { public static void main(String[] args) { FileInputStream fis = null; FileOutputStream fos = null;
try { fis = new FileInputStream(new File(args[0]); fos = new FileOutputStream(new File(args[1]); while((int r = fis.read() != -1) { fos.write((byte)r); } } // to be continued...
Example: cont. ...
catch (FileNotFoundException ex) { ... }
catch (IOException ex) { ... }
finally {
try {
if(fis != null) fis.close();
if(fos != null) fos.close();
} catch (IOException ex) { }
}
}// main
}// class
Data Streams for primitive types
The data streams (DataInputStream and DataOutputStream) read and write Java primitive types in a machine-independent fashion It enables you to write a data file in one machine and read it on another machine that has a different operating system or file structure. Data streams are wrappers for on existing input and output streams: DataInputStream dis = new DataInputStream(inStream);
DataInputStream Methods byte readByte() throws IOException
short readShort() throws IOException
int readInt() throws IOException
long readLong() throws IOException
float readFloat() throws IOException
double readDouble() throws IOException
char readChar() throws IOException
boolean readBoolean() throws IOException
String readUTF() throws IOException
DataOutputStream Methods void writeByte(byte b) throws IOException
void writeShort(short s) throws IOException
void writeInt(int i) throws IOException
void writeLong(long l) throws IOException
void writeFloat(float f) throws IOException
void writeDouble(double d) throws IOException
void writeChar(char c) throws IOException
void writeBoolean(boolean b) throws IOException
void writeBytes(String l) throws IOException
void writeChars(String l) throws IOException
void writeUTF(String l) throws IOException
Example:Using Data Streams
Data I/O Stream Constructors DataInputStream in = new DataInputStream(inpStream); DataInputStream infile = new DataInputStream(new FileInputStream("in.dat"));
Creates a data input stream for file in.dat.
DataOutputStream out=new DataOutputStream(outStream);
DataOutputStream outfile = new DataOutputStream(new FileOutputStream("out.dat"));
Creates a data output stream for file out.dat.
Example:1. Processing Data Streams
import java.io.*;
public class TestDataStream
{
public static void main(String[] args)
{
DataInputStream dis = null;
DataOutputStream dos = null;
// Construct a temp file
File tempFile = new File(“mytemp.dat”);
if(tempFile.exists()) System.exit(0);
// cont.
Example:2. Processing Data Streams
// Write data try { dos = new DataOutputStream( new FileOutputStream(tempFile)); for(int i=0; i < 10; i++) dos.writeInt((int)(Math.random()*1000)); } catch (IOException ex) { ... } finally { try { if(dos != null) dos.close(); } catch (IOException ex) { } } }
3. Processing Data Streams try { // Read data dis = new DataInputStream(tempFile); for(int i = 0; i < 0, i++) System.out.println(dis.readInt()); } catch (FileNotFoundException ex) { System.out.println(“File not found.”) } catch (IOException ex) { System.out.println(ex.getMessage()); } finally { try { if(dis != null) dis.close(); } catch (IOException ex) { System.out.println(ex.getMessage()); } } } //method}// class
Print StreamsThe data output stream outputs a binary represen-tation of data, so you cannot view its contents as text. In Java, you can use print streams to output data into files. These files can be viewed as text.
The PrintStream and PrintWriter classes provide this functionality.
Buffered StreamsJava introduces buffered streams that speed up input and output by reducing the number of reads and writes. In the case of input, a bunch of data is read all at once instead of one byte at a time. In the case of output, data are first cached into a buffer, then written all together to the file.
Using buffered streams is highly recommended!
Buffered Stream Constructors BufferedInputStream (InputStream in) // 512 bytes or
// chars
BufferedInputStream (InputStream in, int bufferSize)
BufferedOutputStream (OutputStream in)
BufferedOutputStream (OutputStream in, int bufferSize)
BufferedReader(Reader in)
BufferedReader(Reader in, int bufferSize)
BufferedWriter(Writer out)
BufferedWriter(Writer out, int bufferSize)
Buffered Streams: ExampleBufferedReader infile = null;String inLine;try { infile = new BufferedReader(new FileReader(filename)); while((inLine = infile.readLine()) != null) { System.out.println(inLine); }} catch(FileNotFoundException ex) { System.out.println(ex.getMessage());} catch(IOException ex) { System.out.println(ex.getMessage());} finally() { try { if(infile != null) infile.close(); }}
Text Input/Output on the Consoles
There are two types of interactive I/O. One involves simple input from the keyboard and simple output in a pure text form. The other involves input from various input devices and output to a graphical environment on frames and applets. The former is referred to as text interactive I/O, and the latter is known as graphical interactive I/O.
Console Output/InputTo perform console output, you can use any of the
methods for PrintStream in System.out.
However, keyboard input is not directly supported in
Java. In order to get input from the keyboard, you first use
the following statements to read a string from the
keyboard. (cont’d)
Console Output/Inputimport java.io.*;public class myInput { /** Read a string from the keyboard */ public static String readString() { BufferedReader br = new BufferedReader( new InputStreamReader(System.in)); // Declare and initialize the string String string = “”; // Get the string from the keyboard try { string = br.getLine(); } catch (IOException ex) { System.out.println(ex); } return string; }
Console Output/Input, cont. /** Read an int value from the keyboard */ public static int readInt() { return Integer.parseInt(readString()); } /** Read a double value from the keyboard */ public static double readDouble() { return Double.parseDouble(readString()); } ... /** Read a character from the keyboard */ public static char readChar() { return readString().charAt(0); }}//class
Object Input and Output
Serializable interface Object Streams Example
The Serializable Interface
The Serializable interface is a marker interface. It has no methods, so you don't need to add additional code in your class that implements Serializable.
Implementing this interface enables the Java
serialization mechanism to automate the process of
storing the objects and arrays.
The Object Streams
Use the ObjectOutputStream class for storing objects and the ObjectInputStream class for restoring objects. These two classes are built upon several other classes.
Object Input/Output import java.io.Serializable; public class MyObject implements Serializable { }. . . try { ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream(new File(fname))); out.writeObject(myObject); out.close(); } catch(IOException e) { ... }. . . try { ObjectInputStream in = new ObjectInputStream( new FileInputStream(new File(fname))); myObject = (MyObject)in.readObject(); } catch(IOException e) { ... }
Example: Write 2D arrayimport java.io.*;import java.io.Serializable;public class WriteMatrix { static double[10][10] data; public static void main(String[] args) { int row = data.length; int col = data[0].length; try { ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream( new File(args[0]))); out.writeObject(data); out.close(); } catch(IOException e) { ... } }//main }//class
Example: Read 2D arrayimport java.io.*;
public class ReadMatrix {
static double[][] data;
public static void main(String[] args) {
try {
ObjectInputStream in = new ObjectInputStream(
new FileInputStream(new File(args[0])));
data = (double[][])in.readObject();
int row = data.length;
int col = data[0].length;
} catch(IOException e) { ... }
}//main
}//class
Example: Write Objectimport java.io.*;public class WriteMyObject { MyObject obj = new MyObject(); // Object to be stored public static void main(String[] args) { try { ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream(new File(args[0]))); out.writeObject(obj); out.close(); } catch(IOException e) { ... } }//main }//class
Example: Read Object
import java.io.*;public class ReadMatrix { static MyObject obj; // Object to be restored public static void main(String[] args) { try { ObjectInputStream in = new ObjectInputStream( new FileInputStream(new File(args[0]))); obj = (MyObject)in.readObject();} catch(IOException exc) { ... } }//main}//class