Java Input / Output

In Java, Input and Output (I/O) is used to process the input and produce the output.

This means an input stream can abstract many different input kinds: from a disk file, a keyboard or a network socket. Likewise, an output stream may refer to the console, a disk file, or a network connection.

Streams-

Java programs perform I/O through streams. A stream is an abstraction that either produces or consumes information. A stream is linked to a physical device by the Java I/O system.

All streams behave in the same manner, even if the actual physical devices to which they are linked differ. Thus, the same I/O classes and methods can be applied to any device.

Streams are a clean way to deal with input/output without having every part of our code understand the difference between a keyboard and a network, for example. Java implements streams within class hierarchies defined in the java.io package.

The concept of sending data from one stream to another (like one pipe feeding into another pipe) has made streams in Java a powerful tool for file processing. We can build a complex file processing sequence using a series of simple stream operations.

This feature can be used to filter data along the pipeline of streams so that we obtain data in the desired format. For example, we can use one stream to get raw data in binary format and then use another stream in series to convert it into integers.

Input and Output Streams:-

Java streams are classified into two basic types: usually input streams and output streams. An input stream extracts (i.e. reads) data from the source and sends it to the program.

The program connects and opens an input stream on the data source and then reads the data serially. Similarly, the program connects and opens an output stream to the destination place of data and writes data out serially. In both cases, the program does not know the details of endpoints (i.e. source and destination).

Byte Streams and Character Streams-

Java2 defines two types of streams: Byte and Character. Byte streams provide a convenient means for handling input and output of bytes. Byte streams are used, for example, when reading or writing binary data. Character streams offer a convenient means for controlling input and output of character.

They use Unicode and therefore, can be internationalized. Also, in some cases, character streams are more efficient than byte streams. The original version of Java (Java 1.0) did not include character streams, and this, all I/O was byte-oriented.

Character streams were added by Java 1.1, and certain byte-oriented classes and methods were deprecated.

Note:

At the lowest level, all I/O is still byte-oriented. The character-based streams provide a convenient and efficient means for handling characters.

These two groups may be further classified base on their purposes. Byte Stream and Character Stream classes contain specialized classes to deal with input and output operations independently on various devices.

We can also cross-group the streams based on the type of source or destination they read from or write to. The source or goal may be a memory, a file or a pipe.

Overview of Byte Stream Classes:-

Byte stream classes are defined by using two-class hierarchies. At the top are two abstract classes:

(1) InputStream and (2) OutputStream

These abstract classes have several concrete subclasses that handle the differences between various devices, such as disk files, network connections and even memory buffers.

InputStream class:-

InputStream classes used to read 8-bit bytes include a superclass known as InputStream and several sub-classes to support various input-related functions.

The superclass InputStream is an abstract class, which defines methods for performing input functions such as:

  • Reading bytes.
  • Closing stream.
  • Marking positions in streams.
  • Skipping ahead in a stream.
  • Finding the number of bytes in a stream.
Methods of InputStream class:
int available()

Gives the number of bytes available in the input (must be overridden by the subclasses). The available method for class InputStream always returns 0.

void close()

Closes this input stream and releases any system resources associated with the stream. The close method of InputStream does nothing.

void mark(int readlimit)

Marks the current position in this input stream. The mark method of InputStream does nothing.

boolean markSupported()

Tests if this input stream supports the mark and resets methods. The markSupported method of InputStream returns false.

abstract int read()

Reads the next byte of data from the input stream. A subclass must provide an implementation of this method.

int read(byte[] b)

Reads some number of bytes from the input stream and stores them into the buffer array b. The number of bytes actually read is returned as an integer.

int read(byte[] b, int offset, int len)

Reads some bytes from the input stream and stores them into the buffer array b starting from position specified by the parameter. The number of bytes reads it returned as an integer.

void reset()

Repositions this stream to the position when the mark method was last called on this input stream. The reset method of InputStream does nothing and always throws IOException.

long skip(long n)

Skips over and discards upto n bytes of data from this input stream and returns the number of bytes skipped.

The DataInput Interface:

The DataInput is an interface, which defines methods for reading primitives from an InputStream.

Methods of DataInput Interface:
boolean readBoolean()

Reads one input byte and returns true if that byte is non-zero and false if that byte is zero.

byte readByte()

Reads and returns one byte input.

char readChar()

Reads an input character and returns its value.

double readDouble()

Reads eight input bytes and returns a double value.

float readfloat()

Reads four input bytes and returns a double value.

void readFully(byte[] b)

Reads some bytes from an input stream and stores them in a buffer array b. This method throws EOFException if this stream reaches the end before reading all the bytes.

void readFully(byte[] b, int off, int len)

Reads len bytes from an input stream and stores them in a buffer array b starting at the position specified by the off. This method throws EOFException if this stream reaches the end before reading all the bytes.

int readInt()

Reads four input bytes and returns an int value.

String readLine()

Reads the next line from the input stream.

long readLong()

Reads eight input bytes and returns a long value.

short readShort()

Reads two input bytes and returns a short value Strig readUTF( ) Reads in a string that has been encoded using a modified UTF-8 format.

int skipBytes(int n)

Attempt to skip over n bytes of data from the input stream, discarding the skipped bytes. The actual number of bytes skipped is returned.

OutputStream classes-

Output stream classes are derived from the base class OutputStream, an abstract class and have many sub-classes for supporting various output-related functions.

The OutputStream class:-

The superclass OutputStream is an abstract class, which defines methods for performing output functions such as:

  • Writing bytes
  • Closing streams
  • Flushing streams
Methods of OutputStream Class:-
void close()

Closes this output stream and releases any stream resources associated with this stream.

void flush()

Flushes this output stream and forces any buffered output bytes to be written out.

void write(byte[] b)

Writes b. length bytes from the specified byte array to its output stream.

void write(byte[] b, int off, int len)

Writes len bytes from the specified byte array starting at offset off to its output stream.

abstract void write( int b)

Writes the specified byte to its output stream.

The DataOutput Interface:-

The DataOutput is an interface, which defines methods for writing primitives to an OutputStream.

Methods of DataOutput Interface:
void writeBoolean(boolean v)

Writes a boolean value to its output stream.

void writeByte(int v)

Writes to the output stream the eight low- order bits of the argument v.

void writeBytes(string s)

Writes the string to the output stream. For every character in the string s, taken in order, one byte is written to the output stream.

void writeChar(int v)

Writes a character value, which is comprised of two bytes, to the output stream.

void writeChars(string s)

The output stream writes every character in the string s in the order of eight bytes.

void writeDouble(double v)

Writes a double value, which is comprised of eight bytes, to the output stream.

void writeFloat(float v)

Writes a float value, which is comprised of four bytes, to the output stream.

void writeInt(int v)

Writes a int value, which is comprised of four bytes, to the output stream.

void writeLong(long v)

Writes a long value, which is comprised of eight bytes, to the output stream.

void writeShort(int v)

Writes a short value, which is comprised of two bytes, to the output stream.

void writeUTF(String str)

Writes two bytes of length information to the output stream, followed by the modified UTF-8 representation of every character in the string s.

Copyright 1999- Ducat Creative, All rights reserved.