What is Java I/O?

Introduction The Java Input/Output (I/O) is a part of java.io package. The java.io package contains a relatively large number of classes that support input and output operations. The classes in the package are primarily abstract classes and stream-oriented that define methods and subclasses which allow bytes to be read from and written to files or other input and output sources. The InputStream and OutputStream are central classes in the package which are used for reading from and writing to byte streams, respectively. The java.io package can be categories along with its stream classes in a hierarchy structure shown below:

InputStream: The InputStream class is used for reading the data such as a byte and array of bytes from an input source. An input source can be a file, a string, or memory that may contain the data. It is an abstract class that defines the programming interface for all input streams that are inherited from it. An input stream is automatically opened when you create it. You cans explicitly close a stream with the close( ) method, or let it be closed implicitly when the object is found as a garbage.

The subclasses inherited from the InputStream class can be seen in a hierarchy manner shown below:

InputStream is inherited from the Object class. Each class of the InputStreams provided by the java.io package is intended for a different purpose.

OutputStream: The OutputStream class is a sibling to InputStream that is used for writing byte and array of bytes to an output source. Similar to input sources, an output source can be anything such as a file, a string, or memory containing the data. Like an input stream, an output stream is automatically opened when you create it. You can explicitly close an output stream with the close( ) method, or let it be closed implicitly when the object is garbage collected. The classes inherited from the OutputStream class can be seen in a hierarchy structure shown below:

OutputStream is also inherited from the Object class. Each class of the OutputStreams provided by the java.io package is intended for a different purpose.

How Files and Streams Work: Java uses streams to handle I/O operations through which the data is flowed from one location to another. For example, an InputStream can flow the data from a disk file to the internal memory and an OutputStream can flow the data from the internal memory to a disk file. The disk-file may be a text file or a binary file. When we work with a text file, we use a character stream where one character is treated as per byte on disk. When we work with a binary file, we use a binary stream. The working process of the I/O streams can be shown in the given diagram.

Classes and Interfaces of the I/O Streams

Classes: The following listing of classes are provided by the java.io package shown in the table:

Class
BufferedInputStream

Description
It used for creating an internal buffer array. It supports the mark and reset methods. This class used for writes byte to output stream. It implements a buffered output stream. This class provides read text from character input stream and buffering characters. It also reads characters, arrays and lines. This class provides write text

BufferedOutputStream

BufferedReader

BufferedWriter

ByteArrayInputStream ByteArrayOutputStream

CharArrayReader

CharArrayWriter

DataInputStream

DataOutputStream

File FileDescriptor

FileInputStream

FileOutputStream

FilePermission FileReader FileWriter FilterInputStream

from character output stream and buffering characters. It also writes characters, arrays and lines. It contains the internal buffer and read data from the stream. This class used for data is written into byte array. This is implement in output stream class. It used for char input stream and implements a character buffer. This class also implements a character buffer and it uses an writer. This class reads the primitive data types from the input stream in a machine format. This class writes the primitive data types from the output stream in machine format. This class shows a file and directory pathnames. This class uses for create a FileInputStream and FileOutputStream. It contains the input byte from a file and implements an input stream. It uses for writing data to a file and also implements an output stream. It provides the permission to access a file or directory. This class used for reading characters file. This class used for writing characters files. This class overrides all methods of InputStream and contains some other input stream.

FilterOutputStream

This class overrides all methods of OutputStream and contains some other output stream. FilterReader It reads the data from the filtered character stream. FilterWriter It writes data from the filtered character stream. InputStream This class represents an input stream of bytes. InputStreamReader It reads bytes and decodes them into characters. LineNumberReader This class has a line numbers ObjectInputStream This class used for recover the object to serialize previously. ObjectInputStream.GetField This class access to president fields read form input stream. ObjectOutputStream This class used for write the primitive data types and also write the object to read by the ObjectInputStream. ObjectOutputStream.GetField This class access to president fields write in to ObjectOutput. ObjectStreamClass Serialization's descriptor for classes. ObjectStreamField This class describes the serializable field. OutputStream This class represents an output stream of bytes. OutputStreamWriter It writes bytes and decodes them into characters. PipedInputStream In this class the data bytes are written into piped output stream. This class also connected into a piped output stream. PipedOutputStream This class also communicates the piped input stream into piped output stream. It creates communication between both. PipedReader It is a piped character-input stream.

PipedWriter PrintStream

PrintWriter

PushbackInputStream

PushbackReader

RandomAccessFile

Reader SequenceInputStream

SerializablePermission StreamTokenizer

StringReader StringWriter

Writer

It is a piped character-output stream. This class adds the functionality of another output stream. This class adds the functionality of another input stream. It also include the another function of input stream. Such as: "push back" or "unread" one byte. This is a character stream reader and reads the data push back into the stream. It supports both reading and writing to a random access file. It used for reading character stream. It represents the logical concatenation of other input stream. This is a serializable permission class. It takes an input stream and parse it into "tokens" . The token to be allowed at the read time. This is a character string class. It has character read source. This is also a character string class. It uses to shows the output in the buffer. It uses for writing to character stream.

Interfaces: The following summary of Interfaces provided by the java.io package shown in the table:

Interface

Description

This interface can be used for reading byte stream and reconstructing the java primitive data types. DataOutput This interface can be used for writing the byte stream and converting data from the java primitive data types. Externalizable This is written in Serializable Stream. It save and store it's contents. FileFilter It can be used for Filtering the Pathnames. FilenameFilter This interface used for Filter the Filenames. ObjectInput This interface used for reading of objects and it extends the DataInput interface. ObjectInputValidation This is a Callback interface. It allows the validation of objects within a graph. ObjectOutput This interface used for writing of objects and it extends the DataOutput interface. This interface used for Constants ObjectStreamConstants writing into Serialization Objects Stream. Serializable This interface implementing in the java.io.Serializable interface. Exceptions Classes: The following summary of the exception classes provided by the java.io package shown in the table:

DataInput

Exceptions
CharConversionException

Description
It provides detail message in the catch block to associated with the CharConversionException This exception indicates the end of file. When the file input stream to be end then EOFException to be occuted. When the open file's

EOFException

FileNotFoundException

pathname does not find then this exception to be occured. InterruptedIOException When the I/O operations to interrupted from any causes then it becomes. InvalidClassException Any problems to be created with class, when the Serializing runtime to be detected. InvalidObjectException When the de-serialized objects failed then it occurs. IOException When the I/O operations to be failed then it occurs. NotActiveException The Serialization or deserialization operations are not active then it occurs. NotSerializableException This exception when the instance is required to a Serializable interface. ObjectStreamException This is a supper class of all exception class. It used for specific to Object Stream Classes. OptionalDataException When the reading data operations to failed then it these exception occurs. It is belonging to the serialized object StreamCorruptedException It thrown when the control information that was read form an object stream vioaltes internal consistency checks. SyncFaieldException The sync operation is failed then SyncFaieldException to be occure. UnsupportedEncodingException The Character Encoding is not supported. UTFDataFormatException A molformed UTF-8 has been read in a data input stream, it implemented by data input interface. WriteAbortedException In this exception to be thrown by the

ObjectStreamException during a write operating.

Reading Text from the Standard Input

Standard Streams: Standard Streams are a feature provided by many operating systems. By default, they read input from the keyboard and write output to the display. They also support I/O operations on files.

Java also supports three Standard Streams:

Standard Input: Accessed through System.in which is used to read input from the keyboard. Standard Output: Accessed through System.out which is used to write output to be display. Standard Error: Accessed through System.err which is used to write error output to be display.

These objects are defined automatically and do not need to be opened explicitly. Standard Output and Standard Error, both are to write output; having error output separately so that the user may read error messages efficiently. System.in is a byte stream that has no character stream features. To use Standard Input as a character stream, wrap System.in within the InputStreamReader as an argument. InputStreamReader inp = new InputStreamReader(system.in); Working with Reader classes: Java provides the standard I/O facilities for reading text from either the file or the keyboard on the command line. The Reader class is used for this purpose that is available in the java.io package. It acts as an abstract class for reading character streams. The only methods that a subclass must implement are read(char[], int, int) and close(). the Reader class is further categorized into the subclasses. The following diagram shows a class-hierarchy of the java.io.Reader class.

However, most subclasses override some of the methods in order to provide higher efficiency, additional functionality, or both. InputStreamReader: An InputStreamReader is a bridge from byte streams to character streams i.e. it reads bytes and decodes them into Unicode characters according to a particular platform. Thus, this class reads characters from a byte input stream. When you create an InputStreamReader, you specify an InputStream from which, the InputStreamReader reads the bytes. The syntax of InputStreamReader is written as: InputStreamReader <variable_name> = new InputStreamReader(system.in) BufferedReader : The BufferedReader class is the subclass of the Reader class. It reads character-input stream data from a memory area known as a buffer maintains state. The buffer size may be specified, or the default size may be used that is large enough for text reading purposes. BufferedReader converts an unbuffered stream into a buffered stream using the wrapping expression, where the unbuffered stream object is passed to the constructor for a buffered stream class. For example the constructors of the BufferedReader class shown as: BufferedReader(Reader in):Creates a buffering character-input stream that uses a default-sized input buffer. BufferedReader(Reader in, int sz): Creates a buffering characterinput stream that uses an input buffer of the specified size.

BufferedReader class provides some standard methods to perform specific reading operations shown in the table. All methods throws an IOException, if an I/O error occurs. Method read( ) read(char[] cbuf, int off, int len) readLine( ) close( ) Return Type int int String void Description Reads a single character Read characters into a portion of an array. Read a line of text. A line is considered to be terminated by ('\n'). Closes the opened stream.

This program illustrates you how to use standard input stream to read the user input..
import java.io.*;

public class ReadStandardIO{ public static void main(String[] args) throws IOException{ InputStreamReader inp = new InputStreamReader(System.in) BufferedReader br = new BufferedReader(inp); System.out.println("Enter text : "); String str = in.readLine(); System.out.println("You entered String : "); System.out.println(str); } }

Output of the Program: C:\nisha>javac ReadStandardIO.java C:\nisha>java ReadStandardIO Enter text :

this is an Input Stream You entered String : this is an Input Stream C:\nisha>

Working With File

In the previous chapter, we learned how to work with the streams. which provide a simple model for reading and writing data. However, streams don't support all the operations that are common with a disk file. In lesson, we will learn how to work with a file using the non-stream file I/O. The File class deals with the machine dependent files in a machine-independent manner i.e. it is easier to write platform-independent code that examines and manipulates files using the File class. This class is available in the java.lang package. The java.io.File is the central class that works with files and directories. The instance of this class represents the name of a file or directory on the host file system. When a File object is created, the system doesn't check to the existence of a corresponding file/directory. If the file exist, a program can examine its attributes and perform various operations on the file, such as renaming it, deleting it, reading from or writing to it. The constructors of the File class are shown in the table: Constructor Description Create File object for default File(path) directory (usually where program is located). Create File object for directory File(dirpath,fname) path given as string. File(dir, fname) Create File object for directory. Thus the statement can be written as:
File f = new File("<filename>");

The methods that are used with the file object to get the attribute of a corresponding file shown in the table.

Method

Description f.exists() Returns true if file exists. f.isFile() Returns true if this is a normal file. f.isDirectory() true if "f" is a directory. Returns name of the file or f.getName() directory. f.isHidden() Returns true if file is hidden. f.lastModified() Returns time of last modification. f.length() Returns number of bytes in file. f.getPath() path name. f.delete() Deletes the file. Renames f to File f2. Returns true if f.renameTo(f2) successful. Creates a file and may throw f.createNewFile() IOException.