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.

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 = 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 character-input 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	Return Type	Description
read( )	int	Reads a single character
read(char[] cbuf, int off, int len)	int	Read characters into a portion of an array.
readLine( )	String	Read a line of text. A line is considered to be  terminated by ('\n').
close( )	void	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>

Download this example

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	Description
BufferedInputStream	It used for creating an internal buffer array. It supports the mark and reset methods.
BufferedOutputStream	This class used for writes byte to output stream. It implements a buffered output stream.
BufferedReader	This class provides read text from character input stream and buffering characters. It also reads characters, arrays and lines.
BufferedWriter	This class provides write text from character output stream and buffering characters. It also writes characters, arrays and lines.
ByteArrayInputStream	It contains the internal buffer and read data from the stream.
ByteArrayOutputStream	This class used for data is written into byte array. This is implement in output stream class.
CharArrayReader	It used for char input stream and implements a character buffer.
CharArrayWriter	This class also implements a character buffer and it uses an writer.
DataInputStream	This class reads the primitive data types from the input stream in a machine format.
DataOutputStream	This class writes the primitive data types from the output stream in machine format.
File	This class shows a file and directory pathnames.
FileDescriptor	This class uses for create a FileInputStream and FileOutputStream.
FileInputStream	It contains the input byte from a file and implements an input stream.
FileOutputStream	It uses for writing data to a file and also implements an output stream.
FilePermission	It provides the permission to access a file or directory.
FileReader	This class used for reading characters file.
FileWriter	This class used for writing characters files.
FilterInputStream	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	It is a piped character-output stream.
PrintStream	This class adds the functionality of another output stream.
PrintWriter	This class adds the functionality of another input stream.
PushbackInputStream	It also include the another function of input stream. Such as: "push back" or "unread" one byte.
PushbackReader	This is a character stream reader and reads the data push back into the stream.
RandomAccessFile	It supports both reading and writing to a random access file.
Reader	It used for reading character stream.
SequenceInputStream	It represents the logical concatenation of other input stream.
SerializablePermission	This is a serializable permission class.
StreamTokenizer	It takes an input stream and parse it into "tokens" . The token to be allowed at the read time.
StringReader	This is a character string class. It has character read source.
StringWriter	This is also a character string class. It uses to shows the output in the buffer.
Writer	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
DataInput	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.
ObjectStreamConstants	This interface used for Constants 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:

Exceptions	Description
CharConversionException	It provides detail message in the catch block to associated with the CharConversionException
EOFException	This exception indicates the end of file. When the file input stream to be end then EOFException to be occuted.
FileNotFoundException	When the open file's 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.