**IO STREAMS**

*IO Stream: Stream are used to perform sequential flow of data. Sequential of
data one location to and other location. The streams are classified into two
types. They are:

1. Byte Streams
2. Character Streams
1. Byte Streams: (Byte by Byte) The Streams that will the perform the
operations Byte by Byte are called as ‘Byte Streams’. These Streams can
handle any kind of data like Text, Audio, Video, Images etc. The Byte
Streams are further classified into two categories.

1.1.Input Stream: These Streams are used to perform Reading operation

from any resource using these Streams we can read data into an application.

Ex: File InputStream

Data InputStream etc.

1.2.OutputStream: These Streams are used to perform writing operation to

any resource. These Streams can he used to send data out of the applications.

Ex: FileOutputStream

BufferedOutputStream etc.

2. Character Streams: (char by char)The Streams that perform the

operation character by character are called as character Streams. These
Streams can handle only text. There also called as Text Streams. The
character Streams are faster then Byte Streams. The character Streams are
further classified into two catagories.
2.1. Reader: These Streams are similar to Input Streams performing
Reading operations from various resources.
Ex: FileReader
BufferedReader
2.2. Writer: These Streams are similar to output Streams
performing writing operations on to various resources.
Ex: FileWriter
PrintWriter
All the Stream related classes are available in“java.io.package”.

1|Page
*DataInputStream: This Stream is used to perform Reading operation from
any resource.

Creation of DataInputStream

Syntax: DataInputStream dis = new DataInputStream(resource);

//pro from Read to keyboard.

import java.io.*; //reading multiple characters and

displaying then
class Readdemo{
int ch;
public static void main(String[] args)
throws IOException{ while((ch = dis.read())!=-1){

//Creating the object of System.out.println((char) ch);

DataInputStream and Connecting it
}
to the resource.
}
DataInputStream dis = new
DataInputStream(System.in); }
input.text(file)

FileInputStream

//Reading a Array(byte) BufferedInputStream

import java.io.*;

*FileInputStream: This Stream is used to Read the contents from a file.

Syntax: FileInputStream fis = new FileInputStream(fileName);

If the fileName that is specified is not available then we get a runtime Exception
called file not found Exception.

import java.util.*; //connecting FileInputStream to a

file
class FileRead{
FileInputStream fis = new
public static void main(String[]
FileInputStream(“input.txt”);
args){

2|Page
//connection BufferedInputStream to System.out.print((char)ch);
FileInputStream
}
BufferedInputStream bis = new
//releasing the resources
BufferedInputStream(fis);
bis.close();
//reading data from a file and
displaying }
int ch; }
while((ch = bis.read())! = -1){

input.txt output.txt

FIS FOS

*FileOutputStream: This calss is used to write the contents into a file.

Syntax:

FileOutputStream fos = new FileOutputStream(fileName);

//This Syntax will overwrite the contents.

FileOutputStream fos = new FileOutputStream(fileName, boolean);

//This Syntax will append the contents.

3|Page
import java.io.*; while((ch = fis.read())! = -1){

class Filecopy{ fos.write(ch);

public static void main(String[] args) }

throws Exception{
fis.close();
FileInputStream fis = new
fos.close();
FileInputStream(“input.txt”);
}
FileOutputStream fos = new
FileOutputStream(“output.txt”,true); }
int ch;

Note: If the output file i.e. specified is not available then we do not get file not
found Exception nested a file with the specified name will be created
automatically.

*FileReader: This class is used to Read the content form a file ‘Char by Char’.
Cretion of file Reader.

Syntax: FileReader fr = new FileReader(fileName);

import java.io.*; while((ch = fr.read())! = -1){

class FileReaderDemo{ System.out.print((char)ch);

public static void main(String[] }

args)throws IOException{ fr.close();

FileReader fr = new }
FileReader(“input.txt”);
}
int ch;
*FileWriter: This file is use to into write the contents into a file character by
character. Creation of filewriter.

Syntax:
FileWriter fw = new FileWriter(fileName);//over writing

FileWriter fw = new FileWriter(fileName, boolean); //append

import java.util.*;

4|Page
class FileWriterdemo{ fw.write(c);

public static void main(Stirng[] args) for(int i =0; i<str.length(); i++){

throws IOException{
fw.write(str.charAt(i));
FileWriter fw = new
}
FileWriter(“abc.txt”);
fw.close();
String str =
“abcdefghijklmnopqrstuvwxyz”; }
fw.writer(str); }
char[] c = str.tocharArray();

***//program write using read a without IO package. ***

import java.lang.*; System.out.print(ch); //write

class demo{ }

public static void main(String[] args) }

throws Exception{

char ch = (char) System.in.read();

//read
***//using with do…while loop ***

***//program can read multiple character from keyboard.***

import java.util.*; ch =(char) System.in.read();

class demo2{ System.out.print(ch);

public static void main(String[] args) }

throws Exception{
while(ch! = -1);
char ch;
}
do{
}

5|Page
***//A program to read to line of data.***

import java.util.*;
(new
class demo{
InputStreamReader(System.in));
public static void main(String[] args)
String str = br.readLine();
throws IOException{
System.out.println(str);
BufferedReader br = new
BufferedReader }

Note:

InputStreamReader is a class that can be use for connecting a ByteStream and

CharacterStream.

System.in InputStream //in = object, inputstream = class

System.out PrintStream //out = object, printstream = class

System.out.println(); //system = java.lang package, out = reference variable object of PSC

*System.out.println: out is a reference variable of print Stream class. Pointing

to the object of printStream class declared as static inside System class.

A static reference variable presenting any class can be access directly by using
class name.

System.out will give us the object of printStream class, with that object we can
call methods of printStream class.

Println method belong to printStream class.

6|Page
//program to derect the connects into a file by using system.out.println.

import java.util.*; System.SetOut(ps);

class demo{ System.out.println(“hi”);

public static void main(String[] args) System.out.println(“h r u”);

throws IOException{
System.out.println(“r u listening?”);
FileoutputStream fos = new
}
FileOutputStream(“divert.txt”);
}
printStream ps = new
printStream(fos);

*DeflaterStreams:(java.util.Zip.*;) package:

DeflaterStreams these streams are used meant for compressing the data.

We can compress the data by reading the or writing the data.

DeflaterInputStream & DeflaterOutputStream both are meant for compressing

the data.

Syntax:
DeflaterInputStream dis = new DeflaterInputStream(InputStream);

DeflaterOutputStream dos = new DeflaterOutputStream(OutputStream);

*InflaterStreams(uncompressing):

* These Streams are used for uncompressing the data.

* We can uncompress the data while reading or while writing.

Syntax:
InflaterInputStream iis = new InflaterInputStream(InputStream);

InflaterOutputStream ios = new InflaterOutputStream(OutputStream);

All the InflaterStreams & DeflaterStreams are available in “import

java.util.zip.*; package.

7|Page
//program to compress the data

import java.io.*; int ch;

import java.util.zip.*; while((ch = fis.read())! = -1){

class Compressdata{ dos.write(ch);

public static void main(String[] args) }

throws IOException{
fis.close();
FileInputStream fis = new
dos.close();
FileInputStream(“input.txt”);
}
FileOutputStream fos = new
FileOutputStream(“temp.txt”); }
DeflaterOutputStream dos = new
DeflaterOutputStream(fos);

Compressed data

input.txt FileInputStream FOS temp.txt

DeflaterOutputStream(1.6 version)

//program uncompressed the data

import java.util.*; FileOutputStream fos = new

FileOutputStream(“output.txt”);
import java.util.*;
int ch;
class Uncompressdata{
while((ch = iis.read())! = -1){
public static void main(String[] args)
throws IOException{ fos.write(ch); {

FileInputStream fis = new iis.close();

FileInputStream(“temp.txt”);
fos.close();
InflaterInputStream iis = new
}
InflaterInputStream(fis);
}

8|Page
9|Page