Input/output in Java
Java brings various Streams with its I/O package that helps the user to perform all the input-
output operations. These streams support all the types of objects, data-types, characters, files etc
to fully execute the I/O operations.
Before exploring various input and output streams lets look at 3 standard or default streams that
Java has to provide which are also most common in use:
System.in: This is the standard input stream that is used to read characters from the keyboard or
any other standard input device.
System.out: This is the standard output stream that is used to produce the result of a program on
an output device like the computer screen.
Here is a list of the various print functions that we use to output statements:
print(): This method in Java is used to display a text on the console. This text is passed as the
parameter to this method in the form of String. This method prints the text on the console and the
cursor remains at the end of the text at the console. The next printing takes place from just here.
Syntax:
System.out.print(parameter);
Example:
// Java code to illustrate print()
Import java.io.*;
class Demo_print {
public static void main(String[] args)
// using print()
// all are printed in the
// same line
System.out.print("GfG! ");
System.out.print("GfG! ");
System.out.print("GfG! ");
Output:
GfG! GfG! GfG!
println(): This method in Java is also used to display a text on the console. It prints the text on
the console and the cursor moves to the start of the next line at the console. The next printing
takes place from the next line.
Syntax:
System.out.println(parameter);
Example:
// Java code to illustrate println()
Import java.io.*;
class Demo_print {
public static void main(String[] args)
// using println()
// all are printed in the
// different line
System.out.println("GfG! ");
System.out.println("GfG! ");
System.out.println("GfG! ");
Output:
GfG!
GfG!
GfG!
printf(): This is the easiest of all methods as this is similar to printf in C. Note that
System.out.print() and System.out.println() take a single argument, but printf() may take multiple
arguments. This is used to format the output in Java.
Example:
// A Java program to demonstrate working of printf() in Java
Class JavaFormatter1 {
Public static void main(String args[])
{
intx = 100;
System.out.printf( "Printing simple"+ " integer: x = %d\n", x);
// this will print it upto
// 2 decimal places
System.out.printf( "Formatted with" + " precision: PI = %.2f\n", Math.PI);
floatn = 5.2f;
// automatically appends zero
// to the rightmost part of decimal
System.out.printf( "Formatted to " + "specific width: n = %.4f\n", n);
n = 2324435.3f;
// here number is formatted from
// right margin and occupies a
// width of 20 characters
System.out.printf("Formatted to "+ "right margin: n = %20.4f\n",n);
Output:
Printing simple integer: x = 100
Formatted with precision: PI = 3.14
Formatted to specific width: n = 5.2000
Formatted to right margin: n = 2324435.2500
System.err: This is the standard error stream that is used to output all the error data that a
program might throw, on a computer screen or any standard output device.
This stream also uses all the 3 above-mentioned functions to output the error data:
print()
println()
printf()
Example:
// Java code to illustrate standard
// input output streams
Import java.io.*;
public class SimpleIO {
public static void main(String args[]) throws IOException
// Input Stream Reader class to read input
InputStreamReader inp = null;
// Storing the input in inp
inp = new InputStreamReader(System.in);
System.out.println("Enter characters, "+ " and '0' to quit.");
charc;
do{
c = (char)inp.read();
System.out.println(c);
} while(c != '0');
Input:
GeeksforGeeks0
Output:
Enter characters, and '0' to quit.
G
e
e
k
s
f
o
r
G
e
e
k
s
0
Types of Streams:
Depending on the type of operations, streams can be divided into two primary classes:
Input Stream: These streams are used to read data that must be taken as an input from a source
array or file or any peripheral device. For eg., FileInputStream, BufferedInputStream,
ByteArrayInputStream etc.
Output Stream: These streams are used to write data as outputs into an array or file or any
output peripheral device. For eg., FileOutputStream, BufferedOutputStream,
ByteArrayOutputStream etc.
Depending on the types of file, Streams can be divided into two primary classes which can be
further divided into other classes as can be seen through the diagram below followed by the
explanations.
ByteStream: This is used to process data byte by byte (8 bits). Though it has many classes, the
FileInputStream and the FileOutputStream are the most popular ones. The FileInputStream is
used to read from the source and FileOutputStream is used to write to the destination. Here is the
list of various ByteStream Classes:
Stream class Description
BufferedInputStream It is used for Buffered Input Stream.
DataInputStream It contains method for reading java standard datatypes.
FileInputStream This is used to reads from a file
InputStream This is an abstract class that describes stream input.
PrintStream This contains the most used print() and println() method
BufferedOutputStream This is used for Buffered Output Stream.
DataOutputStream This contains method for writing java standard data types.
FileOutputStream This is used to write to a file.
OutputStream This is an abstract class that describe stream output.
1. Example:
// Java Program illustrating the
// Byte Stream to copy
// contents of one file to another file.
Import java.io.*;
public class BStream {
public static void main(String[] args) throws IOException
FileInputStream sourceStream = null;
FileOutputStream targetStream = null;
try{
sourceStream = new FileInputStream("sorcefile.txt");
targetStream = new FileOutputStream("targetfile.txt");
// Reading source file and writing
// content to target file byte by byte
Int temp;
while(( temp = sourceStream.read())!= -1)
targetStream.write((byte)temp);
finally{
if(sourceStream != null)
sourceStream.close();
if(targetStream != null)
targetStream.close();
Output:
Shows contents of file test.txt
CharacterStream: In Java, characters are stored using Unicode conventions (Refer this for
details). Character stream automatically allows us to read/write data character by character.
Though it has many classes, the FileReader and the FileWriter are the most popular ones.
FileReader and FileWriter are character streams used to read from the source and write to the
destination respectively. Here is the list of various CharacterStream Classes:
Stream class Description
BufferedReader It is used to handle buffered input stream.
FileReader This is an input stream that reads from file.
InputStreamReader This input stream is used to translate byte to character.
Stream class Description
OutputStreamReader This output stream is used to translate character to byte.
Reader This is an abstract class that define character stream input.
PrintWriter This contains the most used print() and println() method
Writer This is an abstract class that define character stream output.
BufferedWriter This is used to handle buffered output stream.
FileWriter This is used to output stream that writes to file.
2. Example:
// Java Program illustrating that
// we can read a file in a human-readable
// format using FileReader
// Accessing FileReader, FileWriter,
// and IOException
Import java.io.*;
Public class GfG {
Public static void main(String[] args) throws IOException
FileReader sourceStream = null;
try{
sourceStream = new FileReader("test.txt");
// Reading sourcefile and
// writing content to target file
// character by character.
Int temp;
while((temp = sourceStream.read())!= -1)
System.out.println((char)temp);
finally{
// Closing stream as no longer in use
if(sourceStream != null)
sourceStream.close();
Reading and Writing Files
A stream can be defined as a sequence of data. The InputStream is used to read data
from a source and the OutputStream is used for writing data to a destination.
Here is a hierarchy of classes to deal with Input and Output streams.
FileInputStream
This stream is used for reading data from the files. Objects can be created using the
keyword new and there are several types of constructors available.
Following constructor takes a file name as a string to create an input stream object to read
the file −
InputStream f = new FileInputStream("C:/java/hello");
Following constructor takes a file object to create an input stream object to read the file.
First we create a file object using File() method as follows −
File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);
Once you have InputStream object in hand, then there is a list of helper methods which can
be used to read to stream or to do other operations on the stream.
Sr.N
Method & Description
o.
public void close() throws IOException{}
1
This method closes the file output stream. Releases any system resources associated with the
file. Throws an IOException.
protected void finalize()throws IOException {}
2 This method cleans up the connection to the file. Ensures that the close method of this file
output stream is called when there are no more references to this stream. Throws an
IOException.
public int read(int r)throws IOException{}
3
This method reads the specified byte of data from the InputStream. Returns an int. Returns the
next byte of data and -1 will be returned if it's the end of the file.
public int read(byte[] r) throws IOException{}
4
This method reads r.length bytes from the input stream into an array. Returns the total number
of bytes read. If it is the end of the file, -1 will be returned.
5 public int available() throws IOException{}
Gives the number of bytes that can be read from this file input stream. Returns an int.
There are other important input streams available, for more detail you can refer to the
following links −
ByteArrayInputStream
DataInputStream
FileOutputStream
FileOutputStream is used to create a file and write data into it. The stream would create a
file, if it doesn't already exist, before opening it for output.
Here are two constructors which can be used to create a FileOutputStream object.
Following constructor takes a file name as a string to create an input stream object to write
the file −
OutputStream f = new FileOutputStream("C:/java/hello")
Following constructor takes a file object to create an output stream object to write the file.
First, we create a file object using File() method as follows −
File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);
Once you have OutputStream object in hand, then there is a list of helper methods, which
can be used to write to stream or to do other operations on the stream.
Sr.N
Method & Description
o.
public void close() throws IOException{}
1
This method closes the file output stream. Releases any system resources associated with the
file. Throws an IOException.
protected void finalize()throws IOException {}
2 This method cleans up the connection to the file. Ensures that the close method of this file
output stream is called when there are no more references to this stream. Throws an
IOException.
3 public void write(int w)throws IOException{}
This methods writes the specified byte to the output stream.
4 public void write(byte[] w)
Writes w.length bytes from the mentioned byte array to the OutputStream.
There are other important output streams available, for more detail you can refer to the
following links −
ByteArrayOutputStream
DataOutputStream
Example
Following is the example to demonstrate InputStream and OutputStream −
import java.io.OutputStream;
public class fileStreamTest {
public static void main(String args[]) {
try {
byte bWrite [] = {11,21,3,40,5};
OutputStream os = new FileOutputStream("test.txt");
for(int x = 0; x < bWrite.length ; x++) {
os.write( bWrite[x] ); // writes the bytes
}
os.close();
InputStream is = new FileInputStream("test.txt");
int size = is.available();
for(int i = 0; i < size; i++) {
System.out.print((char)is.read() + " ");
}
is.close();
} catch (IOException e) {
System.out.print("Exception");
}
}
}
The above code would create file test.txt and would write given numbers in binary format.
Same would be the output on the stdout screen.
BufferedInputStream and BufferedOutputStream Classes in Java
BufferedInputStream and BufferedOutputStream are two classes in Java that are used to
improve the performance of input and output operations. They do this by buffering data,
which means that they store a small amount of data in memory before writing it to or
reading it from the underlying stream. This can improve performance because it reduces the
number of times that the underlying stream needs to be accessed.
BufferedInputStream and BufferedOutputStream can be used with any type of stream, but
they are especially useful for streams that are slow to access, such as network streams or
file streams.
BufferedInputStream and BufferedOutputStream are very useful classes for improving the
performance of input and output operations. They are easy to use and can be used with any
type of stream.
Here are some additional things to keep in mind when using BufferedInputStream and
BufferedOutputStream:
BufferedInputStream and BufferedOutputStream are both AutoCloseable classes. This
means that they can be automatically closed using the try-with-resources statement.
BufferedInputStream and BufferedOutputStream both have a default buffer size of
8192 bytes. However, you can specify a different buffer size when you create the
object.
BufferedInputStream and BufferedOutputStream can be used to read and write data
from and to any stream, not just files.
Methods of BufferedInputStream Class
Method Description
Returns an estimate of the number of bytes that can be read (or
available() skipped over) from this input stream without blocking, which may
be 0, or 0 when end of stream is detected.
Closes this input stream and releases any system resources
close()
associated with this stream.
Marks the current position in this input stream. A subsequent
mark(int readlimit)
`reset()` will attempt to reposition the stream to this point.
Tells whether this input stream supports the `mark()` and
markSupported()
`reset()` methods.
read() Reads a byte of data from this input stream.
Reads up to `b.length` bytes of data from this input stream into
read(byte[] b)
an array of bytes.
read(byte[] b, int off, Reads up to `len` bytes of data from this input stream into an
int len) array of bytes, starting at offset `off` in the array.
Repositions this stream to the position at which the last `mark()`
reset()
was set.
skip(long n) Skips over and discards `n` bytes of data from this input stream.
Methods of BufferedOutputStream Class
Method Description
Closes this output stream and releases any system resources
close()
associated with this stream.
Flushes this output stream and forces any buffered output bytes
flush()
to be written out to the underlying device.
write() Writes a byte to this output stream.
write(byte[] b) Writes `b.length` bytes from the specified byte array to this
Method Description
output stream.
write(byte[] b, int off, Writes `len` bytes from the specified byte array starting at offset
int len) `off` to this output stream.
Code for Writing and Reading Data from the buffer using BufferedInputStream and
BufferedOutputStream
package practiceproject;
import java.io.*;
import java.util.*;
public class democlass {
public static void main(String[] args) throws IOException {
File obj = new File("satish.txt");
BufferedOutputStream bout = new BufferedOutputStream(new
FileOutputStream(obj));
bout.write(2);
System.out.println("file writing successful");
bout.close();
BufferedInputStream bin = new BufferedInputStream(new
FileInputStream(obj));
int data=bin.read();
System.out.println(data);
bin.close();
}
}
Copy
Code to read data from the buffer after skipping a byte using BufferedInputStream
package practiceproject;
import java.io.*;
import java.util.*;
public class democlass {
public static void main(String[] args) throws IOException {
File obj = new File("satish.txt");
BufferedInputStream bin = new BufferedInputStream(new
FileInputStream(obj));
int data=bin.read();
System.out.println(data);
System.out.println(bin.skip(1));
int data1=bin.read();
System.out.println((char)data1);
}
}
