SCJP Java Programming Exam Cram Notes : java I/o.

Reading

open a stream 

	while more information 
	
	read information 

close the stream

Writing

open a stream 

	while more information 

	write information 

close the stream 
						

For this kind of general I/O Stream/Reader/Writer model is used. These classes are in java.io package. They view the input/output as an ordered sequence of bytes/characters.

We can create I/O chains of arbitrary length by chaining these classes.

These classes are divided into two class hierarchies based on the data type (either characters or bytes) on which they operate. Streams operate on bytes while Readers/Writers operate on chars.

However, it's often more convenient to group the classes based on their purpose rather than on the data type they read and write. Thus, we can cross-group the streams by whether they read from and write to data "sinks" (Low level streams) or process the information as its being read or written (High level filter streams).

Low Level Streams / Data sink streams

Low Level Streams/Data sink streams read from or write to specialized data sinks such as strings, files, or pipes. Typically, for each reader or input stream intended to read from a specific kind of input source, java.io contains a parallel writer or output stream that can create it. The following table gives java.io's data sink streams.

High Level Filter Streams / Processing streams

Processing streams perform some sort of operation, such as buffering or character encoding, as they read and write. Like the data sink streams, java.io often contains pairs of streams: one that performs a particular operation during reading and another that performs the same operation (or reverses it) during writing. This table gives java.io's processing streams.

Reader and InputStream define similar APIs but for different data types. For example, Reader contains these methods for reading characters and arrays of characters:

int read() throws IOException
int read(char cbuf[]) throws IOException

abstract int read(char cbuf[], int offset, int length) throws IOException

InputStream defines the same methods but for reading bytes and arrays of bytes:

abstract int read() throws IOException

int read(byte cbuf[]) throws IOException

int read(byte cbuf[], int offset, int length) throws IOException

Also, both Reader and InputStream provide methods for marking a location in the stream, skipping input, and resetting the current position.

Both Reader and InputStream are abstract. Subclasses should provide implementation for the read() method.

Writer and OutputStream are similarly parallel. Writer defines these methods for writing characters and arrays of characters:

int write(int c) throws IOException

abstract int write(char cbuf[])throws IOException

int write(char cbuf[], int offset, int length) throws IOException

And OutputStream defines the same methods but for bytes:

abstract int write(int c) throws IOException

int write(byte cbuf[]) throws IOException

int write(byte cbuf[], int offset, int length) throws IOException

Writer defines extra methods to write strings.

void write(String str) throws IOException

void write(String str, int offset, int length) throws IOException

Both Writer and OutputStream are abstract. Subclasses should provide implementation for the write() method.

Constructors for some common streams, reader and writers:

File Input Stream

FileInputStream(String name) throws FileNotFoundException

FileInputStream(File file) throws FileNotFoundException

FileInputStream(FileDescriptor fdObj)

File Output Stream

FileOutputStream(String name) throws FileNotFoundException

FileOutputStream(String name, boolean append) throws FileNotFoundException

FileOutputStream (File file) throws FileNotFoundException

FileOutputStream (FileDescriptor fdObj)

Data Input Stream

DataInputStream(InputStream in)

DataOutputStream(OutputStream out)

Buffered Input/Output Stream

BufferedInputStream(InputStream in)

BufferedInputStream(InputStream in, int size)

BufferedOutputStream(OutputStream out)

BufferedOutputStream(OutputStream out, int size)

File Reader

FileReader(File file) throws FileNotFoundException

FileReader (FileDescriptor fdObj)

FileReader (String name) throws FileNotFoundException

File Writer

FileWriter(File file) throws IOException

FileWriter(String name) throws IOException

FileWriter(String name, boolean append) throws IOException

FileWriter(FileDescriptor fdObj)

Input Stream Reader

InputStreamReader(InputStream in)

InputStreamReader(InputStream in, String encodingName) throws UnsupportedEncodingException

Output Stream Writer

OutputStreamWriter(OutputStream out)

OutputStreamWriter (OutputStream out, String encodingName) throws UnsupportedEncodingException

Print Writer

PrintWriter(Writer out)

PrintWriter(Writer out, boolean autoflush)

PrintWriter(OutputStream out)

PrintWriter(OutputStream out, boolean autoflush)

Buffered Reader/Writer

BufferedReader(Reader in)

BufferedReader(Reader in, int size)

BufferedWriter(Writer out)

BufferedWriter (Writer out, int size)

OutputStreamWriter and InputStreamReader are the only ones where you can specify an encoding scheme apart from the default encoding scheme of the host system. getEncoding method can be used to obtain the encoding scheme used.

With UTF-8 Normal ASCII characters are given 1 byte. All Java characters can be encoded with at most 3 bytes, never more.

All of the streams--readers, writers, input streams, and output streams--are automatically opened when created. You can close any stream explicitly by calling its close method. Or the garbage collector can implicitly close it, which occurs when the object is no longer referenced.

Closing the streams automatically flushes them. You can also call flush method.

New FileWriter("filename") or FileOutputStream("filename") will overwrite if "filename" is existing or create a new file, if not existing. But we can specify the append mode in the second argument.

Print writers provide the ability to write textual representations of Java primitive values. They have to be chained to the low-level streams or writers. Methods in this class never throw an IOException.

PrintStream and PrintWriter classes can be created with autoflush feature, so that each println method will automatically be written to the next available stream. PrintStream is deprecated.(though System.out and System.err are still of this type)

System.in is of InputStream type.

System.in, System.out, System.err are automatically created for a program, by JVM.

Use buffered streams for improving performance.BufferedReader provides readLine method.

User defined classes must implement Serializable or Externalizable interfaces to be serialized.

Serializable is a marker interface with no methods. Externalizable has two methods to be implemented - readExternal(ObjectInput) and writeExternal(ObjectOutput).

ObjectOutputStream can write both Java Primitives and Object hierarchies. When a compound object is serialized all its constituent objects that are serializable are also serialized.

ObjectOutputStream implements ObjectOutput, which inherits from DataOutput.

All AWT components implement Serializable (Since Component class implements it), so by default we can just use an ObjectOutputStream to serialize any AWT component.

File class is used to navigate the file system.

Constructing a File instance (or Garbage-Collecting it) never affects the file system.

File class doesn't have a method to change the current working directory.

File constructors

File Methods

Instances of the file descriptor class serve as an opaque handle to the underlying machine-specific structure representing an open file or an open socket.

Applications should not create their own file descriptors

RandomAccessFile lets you read/write at arbitrary places within files.

RAF provides methods to read/write bytes.

RAF also provides methods to read/write Java primitives and UTF strings. (RAF implements the interfaces DataInput and DataOutput)

File and RAF instances should be closed when no longer needed.

All reading/writing operations throw an IOException. Need to catch or declare our methods to be throwing that exception.

Read/Write methods throw a SecurityException if the application doesn't have rights for the file.

RAF cannot be chained with streams/readers/writers.

RAF Constructors

RandomAccessFile(File file, String mode) throws FileNotFoundException, IllegalArgumentException, SecurityException 
 
Creates a random access file stream to read from, and optionally to write to, the file specified by the File argument.  

RandomAccessFile(String name, String mode) throws FileNotFoundException, IllegalArgumentException, SecurityException  

Creates a random access file stream to read from, and optionally to write to, a file with the specified name.  

The mode argument must either be equal to "r" or "rw", indicating either to open the file for input or for both input and output.

Some RAF methods

long getFilePointer() throws IOException  

Returns the offset from the beginning of the file, in bytes, at which the next read or write occurs.

void seek(long pos) throws IOException

Sets the file-pointer offset, measured from the beginning of this file, at which the next read or write occurs. The offset may be set beyond the end of the file. Setting the offset beyond the end of the file does not change the file length. The file length will change only by writing after the offset has been set beyond the end of the file.  

long length() throws IOException

Returns the length of this file, measured in bytes.  

Previous    Contents    Next