Java I/O

CORE JAVA
CHP 5. JAVA INPUT-OUTPUT
MR. JAYANT. P. DALVI

STREAM
• Java I/O (Input and Output) is used to process the input and produce
the output.
• Java uses the concept of a stream to make I/O operation fast. The
java.io package contains all the classes required for input and output
operations.
• We can perform file handling in Java by Java I/O API.

STREAM
• A stream is a sequence of data. In Java, a stream is composed of bytes. It's called a stream because it is like a
stream of water that continues to flow.
• In Java, 3 streams are created for us automatically. All these streams are attached with the console.
1) System.out: standard output stream
2) System.in: standard input stream
3) System.err: standard error stream
• Let's see the code to print output and an error message to the console.
• System.out.println("simple message");
• System.err.println("error message");
• Let's see the code to get input from console.
• int i=System.in.read();//returns ASCII code of 1st character
• System.out.println((char)i);//will print the character

TYPES OF STREAM
• OutputStream
• Java application uses an output
stream to write data to a
destination; it may be a file, an
array, peripheral device or
socket.
• InputStream
• Java application uses an input
stream to read data from a
source; it may be a file, an array,
peripheral device or socket.

InputStream class
• InputStream class is an abstract class. It is the
superclass of all classes representing an input stream
of bytes.
• Useful methods of InputStream
1) public abstract int read()throws IOException-reads
the next byte of data from the input stream. It returns -1
at the end of the file.
2) public int available()throws IOException- returns an
estimate of the number of bytes that can be read from
the current input stream.
3) public void close()throws IOException- is used to
close the current input stream.

OutputStream class
• OutputStream class is an abstract class. It is the
superclass of all classes representing an output
stream of bytes. An output stream accepts output
bytes and sends them to some sink.
• Useful methods of OutputStream
1) public void write(int)throws IOException- is used to
write a byte to the current output stream.
2) public void write(byte[])throws IOException- is used
to write an array of byte to the current output stream.
3) public void flush()throws IOException- flushes the
current output stream.
4) public void close()throws IOException- is used to
close the current output stream.

FileInputStream Class
• Java FileInputStream class obtains input bytes from a
file. It is used for reading byte-oriented data (streams
of raw bytes) such as image data, audio, video etc. You
can also read character-stream data. But, for reading
streams of characters, it is recommended to use
FileReader class.
• Java FileInputStream class declaration
• Let's see the declaration for java.io.FileInputStream
class:
public class FileInputStream extends InputStream
1. methods :
• int available()-It is used to return the
estimated number of bytes that can be read
from the input stream.
• int read()- It is used to read the byte of data
from the input stream.
• int read(byte[] b)- It is used to read up to
b.length bytes of data from the input stream.
• int read(byte[] b, int off, int len)- It is used to
read up to len bytes of data from the input
stream.
• void close()-It is used to closes the stream.

program of reading single character
import java.io.FileInputStream;
public class DataStreamExample {
public static void main(String[] args) {
try{
FileInputStream fin=new FileInputStream("D:testout.txt");
int i=fin.read();
System.out.print((char)i);
fin.close();
}catch(Exception e){System.out.println(e);}
}
}

Java FileInputStream example 2: read all
charactersimport java.io.FileInputStream;
public class DataStreamExample {
public static void main(String args[]){
try{
int i=0;
while((i=fin.read())!=-1){
}
fin.close();
}
}

Java FileOutputStream Class
• Java FileOutputStream is an output stream used for
writing data to a file.
• If you have to write primitive values into a file, use
FileOutputStream class. You can write byte-oriented
as well as character-oriented data through
FileOutputStream class. But, for character-oriented
data, it is preferred to use FileWriter than
FileOutputStream.
• FileOutputStream class declaration
• Let's see the declaration for
Java.io.FileOutputStream class:
public class FileOutputStream extends OutputStream
• FileOutputStream class methods
• protected void finalize()- It is used to clean up the
connection with the file output stream.
• void write(byte[] ary) - It is used to write
ary.length bytes from the byte array to the file output
stream.
• void write(byte[] ary, int off, int len)- It is used to write
len bytes from the byte array starting at offset off to the
file output stream.
• void write(int b)- It is used to write the specified byte to
the file output stream.
• void close()- It is used to closes the file output stream.

Java FileOutputStream Example 1: write byte
import java.io.FileOutputStream;
public class FileOutputStreamExample {
try{
FileOutputStream fout=new FileOutputStream("D:testout.txt");
fout.write(65);
fout.close();
System.out.println("success...");
}
}

Java FileOutputStream example 2: write string
import java.io.FileOutputStream;
public class FileOutputStreamExample {
try{
FileOutputStream fout=new FileOutputStream("D:testout.txt");
String s="Welcome to javaTpoint.";
byte b[]=s.getBytes();//converting string into byte array
fout.write(b);
fout.close();
System.out.println("success...");
}
}

Java Reader Class
• Java Reader is an abstract class for reading character streams. The only methods that a subclass
must implement are read(char[], int, int) and close().
• Constructor:
• protected Reader()- It creates a new character-stream reader whose critical sections will
synchronize on the reader itself.
• Methods:
• abstract void close()-It closes the stream and releases any system resources associated with it.
• int read()- It reads a single character.
• int read(char[] cbuf)- It reads characters into an array.
• abstract int read(char[] cbuf, int off, int len)- It reads characters into a portion of an array.
• int read(CharBuffer target)-It attempts to read characters into the specified character buffer.

Reader class
import java.io.*;
public class ReaderExample {
try {
Reader reader = new FileReader("D:testout.txt");
int data = reader.read();
while (data != -1) {
System.out.print((char) data);
data = reader.read();
}
reader.close();
} catch (Exception ex) {
System.out.println(ex.getMessage());
}
}
}

Java Writer
• It is an abstract class for writing to character streams. The methods
that a subclass must implement are write(char[], int, int), flush(), and
close().
• Constructor
• protected Writer()- It creates a new character-stream writer whose
critical sections will synchronize on the writer itself.

Writer class
• Methods:
• Writer append(char c)- It appends the specified character to this writer.
• Writer append(CharSequence csq)- It appends the specified character sequence to this writer
• Writer append(CharSequence csq, int start, int end)- It appends a subsequence of the specified character
sequence to this writer.
• abstract void close()- It closes the stream, flushing it first.
• abstract void flush()-It flushes the stream.
• void write(char[] cbuf) -It writes an array of characters.
• abstract void write(char[] cbuf, int off, int len)-It writes a portion of an array of characters.
• void write(int c)-It writes a single character.
• void write(String str)-it writes a string.
• void write(String str, int off, int len) -It writes a portion of a string.

writer example
import java.io.*;
public class WriterExample1 {
try {
Writer w = new FileWriter("output.txt");
String content = "I love my country";
w.write(content);
w.close();
System.out.println("Done");
} catch (IOException e) {
e.printStackTrace();
}
}
}

Java FileReader Class
• Java FileReader class is used to read data from the file. It returns data
in byte format like FileInputStream class.
• It is character-oriented class which is used for file handling in java.
• Methods of FileReader class:
• int read()- It is used to return a character in ASCII form. It returns -1 at
the end of file.
• void close()-It is used to close the FileReader class.

FILEREADER CLASS EXAMPLE
package com.javatpoint;
import java.io.FileReader;
public class FileReaderExample {
public static void main(String args[])throws Exception{
FileReader fr=new FileReader("D:testout.txt");
int i;
while((i=fr.read())!=-1)
fr.close();
}
}

Java FileWriter Class
• Java FileWriter class is used to write character-oriented data to a file. It is character-
oriented class which is used for file handling in java.
• Unlike FileOutputStream class, you don't need to convert string into byte array because it
provides method to write string directly.
• Methods of FileWriter class
• void write(String text) - It is used to write the string into FileWriter.
• void write(char c)- It is used to write the char into FileWriter.
• void write(char[] c)- It is used to write char array into FileWriter.
• void flush()- It is used to flushes the data of FileWriter.
• void close()- It is used to close the FileWriter.

FILEWRITER CLASS EXAMPLE
import java.io.FileWriter;
public class FileWriterExample {
try{
FileWriter fw=new FileWriter("D:testout.txt");
fw.write("Welcome to javaTpoint.");
fw.close();
System.out.println("Success...");
}
}

Java BufferedInputStream Class
• Java BufferedInputStream class is used to read information from stream. It
internally uses buffer mechanism to make the performance fast.
• The important points about BufferedInputStream are:
• When the bytes from the stream are skipped or read, the internal buffer
automatically refilled from the contained input stream, many bytes at a time.
• When a BufferedInputStream is created, an internal buffer array is created.

Java BufferedInputStream class methods
• int available()- It returns an estimate number of bytes that can be
read from the input stream without blocking by the next invocation
method for the input stream.
• int read()- It read the next byte of data from the input stream.
• int read(byte[] b, int off, int ln)- It read the bytes from the specified
byte-input stream into a specified byte array, starting with the given
offset.
• void close()-It closes the input stream and releases any of the system
resources associated with the stream.

BUFFEREDINPUTSTREAM CLASS
import java.io.*;
public class BufferedInputStreamExample{
try{
BufferedInputStream bin=new BufferedInputStream(fin);
int i;
while((i=bin.read())!=-1){
}
bin.close();
fin.close();
}
}

Java BufferedOutputStream Class
• Java BufferedOutputStream class is used for buffering an output
stream. It internally uses buffer to store data. It adds more efficiency
than to write data directly into a stream. So, it makes the
performance fast.
• For adding the buffer in an OutputStream, use the
BufferedOutputStream class.

Java BufferedOutputStream class methods
• void write(int b)-It writes the specified byte to the buffered output
stream.
• void write(byte[] b, int off, int len)- It write the bytes from the
specified byte-input stream into a specified byte array, starting with
the given offset
• void flush()- It flushes the buffered output stream.

EXAMPLE
• In this example, we are writing
the textual information in the
BufferedOutputStream object
which is connected to the
FileOutputStream object. The
flush() flushes the data of one
stream and send it into another.
It is required if you have
connected the one stream with
another.
import java.io.*;
public class BufferedOutputStreamExample{
FileOutputStream fout=new
FileOutputStream("D:testout.txt");
BufferedOutputStream bout=new
BufferedOutputStream(fout);
String s="Welcome to javaTpoint.";
byte b[]=s.getBytes();
bout.write(b);
bout.flush();
bout.close();
fout.close();
System.out.println("success");
}
}

Java BufferedReader Class
• Java BufferedReader class is
used to read the text from a
character-based input stream. It
can be used to read data line by
line by readLine() method. It
makes the performance fast. It
inherits Reader class.
• Java BufferedReader class methods
• int read()- It is used for reading a
single character.
• int read(char[] cbuf, int off, int len)-
It is used for reading characters
into a portion of an array.
• void close()- It closes the input
stream and releases any of the
system resources associated with
the stream.

EXAMPLE
import java.io.*;
public class BufferedReaderExample {
FileReader fr=new FileReader("D:testout.txt");
BufferedReader br=new BufferedReader(fr);
int i;
while((i=br.read())!=-1){
}
br.close();
fr.close();
}
}

Java BufferedWriter Class
• Java BufferedWriter class is used to provide buffering for Writer instances. It makes the
performance fast. It inherits Writer class. The buffering characters are used for providing the
efficient writing of single arrays, characters, and strings.
• Class methods
• void newLine() It is used to add a new line by writing a line separator.
• void write(int c)-It is used to write a single character.
• void write(char[] cbuf, int off, int len)-It is used to write a portion of an array of characters.
• void write(String s, int off, int len)-It is used to write a portion of a string.
• void flush()-It is used to flushes the input stream.
• void close()- It is used to closes the input stream

EXAMPLE
import java.io.*;
public class BufferedWriterExample {
public static void main(String[] args) throws Exception {
FileWriter writer = new FileWriter("D:testout.txt");
BufferedWriter buffer = new BufferedWriter(writer);
buffer.write("Welcome to javaTpoint.");
buffer.close();
System.out.println("Success");
}
}

Java - ObjectStreamClass • ObjectStreamClass act as a
Serialization descriptor for class.
This class contains the name and
serialVersionUID of the class.

Java I/O

More Related Content

Java I/O