Streams-Managing Input/Output Files In Java

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. Java I/O stream is the flow of data that you can either read from, or you can write to. It is used to perform read and write operations in file permanently. Java uses streams to perform these tasks. Java I/O stream is also called File Handling, or File I/O. It is available in java.io package and provides classes for system input and output through files, network streams, memory buffers, etc.

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.

Some input-output stream will be initialized automatically by the JVM and these streams are available in System class as in, out, and err variable.

in reference refers to the default input device, i.e. keyboard.

out and err refers to the default output device, i.e. console.

Streams based on data are of two types namely:

1.Binary streams or Byte streams: These handle data in bytes (8 bits) i.e., the byte stream classes read/write data of 8 bits. Using these you can store characters, videos, audios, images etc.

All byte stream classes are derived from base abstract classes called InputStream and OutputStream. 

2.Character Streams: These handle data in 16 bit Unicode. Using these you can read and write text data only. Character stream is used to read and write a single character of data.

All the character stream classes are derived from base abstract classes Reader and Writer.

The InputStream class of the java.io package is an abstract superclass that represents an input stream of bytes. Since InputStream is an abstract class, it is not useful by itself. However, its subclasses can be used to read data.

Working of Java OutputStream and InputStream

Diagram to illustrates all the input and output Streams (classes) in Java

 

Streams are the sequence of bits(data): 

There are two types of streams:

1.Input Streams (File.txt which is placed in harddisk to API interface(Program shell)

2.Output Streams  (API interface(Program shell) to File.txt which is placed in harddisk )

 

Input Streams:(FILE TO API)

Java application uses an input stream to read data from various input devices like keyboard, file, an array, peripheral device, network or socket etc.

The InputStream class of the java.io package is an abstract superclass that represents an input stream of bytes. Since InputStream is an abstract class, it is not useful by itself. However, its subclasses can be used to read data.

Subclasses of InputStream

In order to use the functionality of InputStream, we can use its subclasses. Some of them are:

• FileInputStream
• ByteArrayInputStream
• ObjectInputStream
• BufferedInputStream
• DataInputStream

Creating an InputStream

In order to create an InputStream, we must import the java.io.InputStream package first. Once we import the package, here is how we can create the input stream.

// Creates an InputStream
InputStream object1 = new FileInputStream();

Here, we have created an input stream using FileInputStream. It is because InputStream is an abstract class. Hence we cannot create an object of InputStream.

Methods of InputStream (Read from a file into API )

The InputStream class provides different methods that are implemented by its subclasses. Here are some of the commonly used methods:

read() - reads one byte of data from the input stream

 

read(byte[] array) - reads bytes from the stream and stores in the specified array 

 

available() - returns the number of bytes available in the input stream

 

close() - closes the input stream
 

Ex:

 //import java.io.FileInputStream;
//import java.io.InputStream;
import java.io.*;
public class MainRead
{
  public static void main(String args[])
   {
    byte[] array = new byte[10];
    try
    {
    InputStream ip = new FileInputStream("input.txt");
    System.out.println("Available bytes in the file: " + ip.available());
    // Read byte from the input stream
    ip.read(array);
    System.out.println("Data read from the file: d:\\input.txt");
    // Convert byte array into string
    String data = new String(array);
    System.out.println(data);
    // Close the input stream
    ip.close();
    }
    catch (Exception e)
    {
    e.getStackTrace();
    }
   }
}

Output:

In the above example, we have created an input stream using the FileInputStream class. The input stream is linked with the file input.txt.

InputStream input = new FileInputStream("input.txt");

 

Note:

        To read data from the input.txt file, we have implemented the following two methods.

in.read(array); // to read data from the input stream

in.close();   // to close the input stream
 
Output Streams: (API TO FILE )

Java application uses an output stream to write the data to various output devices like monitor, file, an array, network, peripheral device or socket etc.

The OutputStream class of the java.io package is an abstract superclass that represents an output stream of bytes. Since OutputStream is an abstract class, it is not useful by itself. However, its subclasses can be used to write data.

Subclasses of OutputStream

In order to use the functionality of OutputStream, we can use its subclasses. 

Some of them are:

• FileOutputStream
• ByteArrayOutputStream
• ObjectOutputStream
• BufferedOutputStream
• DataOutputStream

Create an Output Stream

In order to create an OutputStream, we must import the java.io.OutputStream package first.

Creating an Output Stream
OutputStream obj=new FileOutputStream();

Here, we have created an object of output stream using FileOutputStream. It is because OutputStream is an abstract class, so we cannot create an object of OutputStream.

Methods of OutputStream ( write from API into file )
write() - writes the specified byte to the output stream
 

write(byte[] array) - writes the bytes from the specified array to the output stream 

 

flush() - forces to write all data present in output stream to the destination
 

close() - closes the output stream

OutputStream Using FileOutputStream 

Ex:

import java.io.FileOutputStream;
import java.io.OutputStream;
public class MainW
{
  public static void main(String args[])
  {
    String data = "ram is a boy This is a line of text inside the file.";
    try
    {
    OutputStream out = new FileOutputStream("output.txt");
    // Converts the string into bytes
    byte[] dataBytes = data.getBytes();
    // Writes data to the output stream
    out.write(dataBytes);
    System.out.println("Data is written to the file.");
    // Closes the output stream
    out.close();
    }
    catch (Exception e)
    {
    e.getStackTrace();
    }
  }
}

Output:

Note:

        To write data to the output.txt file,we have implemented these methods

output.write(); // To write data to the file
output.close(); // To close the output stream

Character Stream classes

Character Stream Classes are used to read characters from the source and write characters to destination. There are two kinds of Character Stream classes - Reader classes and Writer classes. 

Reader Classes: These classes are subclasses of an abstract class, Reader and they are used to read characters from a source(file, memory or console).

Writer Classes: These classes are subclasses of an abstract class, Writer and they used to write characters to a destination(file, memory or console).

Reader:

Reader class and its subclasses are used to read characters from source.

Reader class is a base class of all the classes that are used to read characters from a file, memory or console. Reader is an abstract class and hence we can't instantiate it but we can use its subclasses for reading characters from the input stream.

 
Methods of Reader class.
Methods            Description

int read()         This method reads a characters from the input stream.

 

int read(char[] ch)       This method reads a chunk of characters from the input stream and store them in its char array, ch.

 

close()                This method closes this output stream and also frees any system resources connected with it.

Writer:

Writer class and its subclasses are used to write characters to a file, memory or console. Write class is a base class of all the classes that are used to write characters to a file, memory or console.Writer is an abstract class and hence we can't create its object but we can use its subclasses for writing characters to the output stream.

Methods of Writer class:

Methods of Writer class provide support for writing characters to the output stream. As this is an abstract class. Hence, some undefined abstract methods are defined in ths subclasses of OutputStream.

Methods                 Description
abstract void flush() This method flushes the output steam by forcing out buffered bytes to be written out.

void write(int c)         This method writes a characters(contained in an int) to the output stream. 

void write(char[] arr)      This method writes a whole char array(arr) to the output stream.

abstract void close() This method closes this output stream and also frees any resources connected with this output stream.

Example :Program to create a file, write data to the file, read and display the contents of the file. (OR)
Write a program to demonstrate Input / Output Streams in Java.
Note : You need to write two programs(need to create two files), One to input the data and the other to read the data.

File Name : FileCreation.java ( API TO FILE )
Note: The above file is used to input the data which in turn save the inputted data into a file named “rkdata.txt” )
import java.io.*;
public class FileCreation
{
  public static void main(String[] args)
  {   
    try
    {
    InputStreamReader is = new InputStreamReader(System.in);
    BufferedReader b=new BufferedReader(is);
    String st=null,ct="";
    char res='t';
    Writer w = new FileWriter("rkdata.txt");
    //String content = "This is to add a single line text...";
    while(res!='x')
    {
    st=b.readLine(); //Reads data in the stream character wise.
    res=st.charAt(0);
    if(res=='x')
        break;
    ct=ct+st+"\r\n"; //here \r\n combination is to produce a new line
    }
    w.write(ct);
    w.close();
    System.out.println("File Is Saved!!!");
    }
    catch (IOException e)
    {
    e.printStackTrace();
    }
  }
}

Output:

Command to compile: I:\>javac FileCreation.java 

Command to execute I:\>java FileCreation
ram is a boy 

x
File Is Saved!!!
Now check out  your file rkdata.txt file 

File Name : FileRead.java (file to API )
Note: The above file is used to read the data from the file named “vldata.txt” ) 

import java.io.*;
public class FileRead
{
   public static void main(String[] args)
    {
     BufferedReader br=null;
     try
     {
      String s;
      br=new BufferedReader(new FileReader("vldata.txt"));
      while ((s=br.readLine()) != null)
      {
       System.out.println(s);
      }
     }
     catch (IOException e)
      {
       e.printStackTrace();
      }
      finally
       {
        try
        {
        if (br!=null)
        br.close();
        }
        catch(IOException ex)
        {
        ex.printStackTrace();
        }
      }
    }
}

Output: