The SequencelnputStream class allows you to concatenate (or combine) two or more input streams serially and make them appear as if they were a single input stream. Each input stream is read beginning from the first one until end of file (EOF) is reached, where upon it reads from the second one and so on, until end of file is reached on the last of the contained input streams.

In order to create SequencelnputStream, the following two constructors are provided.

SequencelnputStream(IntputStream s1, InputStream s2)

This constructor creates a SequencelnputStream that reads from the InputStream s1 until its EOF is reached, then closes it and switched to reading from InputStream s2 until itsEOF is reached.

SequencelnputStream(Enumeration e)

This constructor creates a SequencelnputStream initialized to the specified enumeration of InputStreams.

Now let us consider a program that uses SequencelnputStream to concatenate two files.

import java.io.*;  
 class SequenceInputStreamExample 
 { 
      public static void main(String[] args) 
     { 
         int ch; 
         try 
         { 
           FileInputStream file1 = new  FileInputStream  ("std.dat"); 
           FileInputStream file2 = new FileInputStream  ("mydata.dat"); 
           SequenceInputStream fin=new SequenceInputStream(file1,file2); 
           while((ch=fin.read())!=-1) 
               System.out.println(ch); 
               fin.close(); 
           } 
           catch(IOException e)  { e.printStackTrace(); } 
         } 
      } 
 

The java.io.PrintWriter is another very convenient I/O class that makes writing text to a file as easy as writing text to the console. The PrintWri ter class defines several constructors, the one we would be using is as follows.

Printwriter(OutputStream oStream, boolean autoFlush)

Here, oStreamis an object oftype OutputStream and autoFlush is an boolean variable which if set to true flushes the output stream every time a prin tln () method is invoked.

PrintWriter includes different versions of the print () and prin tln () methods of all types such as int, float etc. including Object. Thus, you can use these methods in the same way as they have been used in System. out. If the argument is not a primitive type, the printWriter methods will call the Object’s toString () method and then print out the result.

Now let us consider a program that reads lines of text typed at the keyboard and then writes the same text into a file by appending a line number at the front of each line.

import java.io.*; 
 import java.util.Scanner; 
 public class PrintWriterExample 
 { 
       public static void main(String[] args) throws FileNotFoundException 
       { 
          Scanner input = new Scanner(System.in); 
          System.out.println("Enter Name of File to Read : "); 
          String inputfileName = input.next(); 
          System.out.print("Enter Name of File in Which Data to be Written : "); 
          String outputfileName = input.next(); 
          FileReader reader = new FileReader(inputfileName); 
          Scanner in = new Scanner(reader); 
          PrintWriter out = new PrintWriter(outputfileName); 
          int lineNumber = 1; 
          while (in.hasNext()) 
          { 
               String line = in.nextLine(); 
               out.print(lineNumber + " : " + line); 
               lineNumber++; 
          } 
              System.out.println("Data Written Successfully"); 
       } 
    } 
 

The java.io.BufferedReader and java.io.BufferedWriter classes are the character based equivalents of the byte oriented BufferedlnputStream and BufferedOutputStream classes.

When a program reads from a BufferedReader, text is taken from buffer (a block of memory) rather than directly from the underlying input stream until the buffer is empty. At this point, a read request to the underlying character stream extracts a new block of data, which refills the buffer. When a program writes to a BufferedWriter, the text is placed in the buffer. The text is moved to the underlying output stream or other target only when the buffer files ·up or when the writer is explicitly flushed, which can make writes much faster than would otherwise.

In order to create BufferedReader, one of the following two constructors can be used.

BufferedReader(Reader in}

BufferedReader(Reader in, int bufferSize}

The first argument in is Reader object which is the underlying character input stream from which data will be read. If the buffer size is not set, the default size of 8192 characters is used. Similarly, to create BufferedWriter, one of the following two constructors are used.

BufferedWriter(Writer out)

BUfferedWriter(Writer out, int bufferSize}

The first argument out isa Writer object which is the underlying character output stream to which buffered data is written. If buffer size is not set, the default size of 8192 characters is used. The BufferedReader and BufferedWriter classes have the usual methods associated with Reader and Writer classes like read () , wri te (), close () etc. In addition, they also provide the following methods.

• String readLine () : The readLine () method of the BufferedReader class reads a single line of text and returns it as a string. The return string is null when the operation attempts to read past the end of the file (EOF).

• void newline () .: The newLine () method of the BufferedWri ter class sends the preferred end of line character (or characters) for the platform being used to run the program.

Now let us consider a program that reads a file and converts its contents to uppercase and write them to a new file.

import java.io.*;       
 public class BufferedReaderWriter  
 { 
        public static void main(String[] args) 
        { 
              try 
             { 
                    BufferedReader br = new BufferedReader(new FileReader("java.txt")); 
                    BufferedWriter bw = new BufferedWriter(new FileWriter("java1.txt")); 
                    int ch; 
                    while ((ch = br.read()) != -1) 
                            {    
                                  if (Character.isLowerCase((char) ch)) 
                                     bw.write(Character.toUpperCase((char) ch)); 
                                  else 
                                          bw.write((char) ch); 
                            } 
                                  br.close(); 
                                  bw.close(); 
             } 
                                  catch(Exception e) { e.printStackTrace();} 
         } 
 } 
 

Java provides java.io.FileReader and java.io.FileWriter classes for reading from and writing characters to a file. The FileReader and FileWri ter classes can be used almost identically to the FileInputStream and FileOutputStream character stream classes.

In order to open a file for reading characters, create a FileReader object. For this, the FileReader class provides the following commonly used constructors,

• FileReader(File fileObj)

• FileReader(String filename)

Here, filename specifies the name of the file and fileObj is a file object that describes the file. If the file to be opened doesnot exist, both these constructors throw java.io.FileNotFoundException.

In order to open a file for writing characters, create a FileWriter object. For this, FileWriter class provides the following commonly used constructors

FileWriter(File file obj)

FileWriter(String filename)

FileWriter(File fileObj, boolean append)

FileWriter(String filename, boolean append)

Here, filename specifies the name of the file and fileObj is a file object that describes the file. If the file doesnot exist, a new file would be created. If the file exists, the first two constructors overwrite the existing contents of the file. To retain the existing contents and append the new data at the end of the file, use the last two constructors and set the second argument append to true.

These constructors throw an IOException on failure.

Now let us consider a program that writes some text into a file and then reads the contents of the file character by character

import java.io.*; 
 class FileReaderWriter 
 { 
       public static void main(String[] args) 
      { 
          int ch; 
          String str="Welcome Java World"; 
          try 
          { 
            FileWriter fileWrite = new FileWriter("java.txt");    
            fileWrite.write(str); 
            fileWrite.close(); 
          } 
          catch(IOException e)  { e.printStackTrace();} 
          try 
          { 
               FileReader fileRead=new FileReader("java.txt"); 
               while((ch=fileRead.read())!=-1) 
               System.out.print((char)ch); 
               fileRead.close(); 
           } 
               catch(IOException e)  { e.printStackTrace();} 
       } 
 } 
 

Java also allows you to access the contents of a file in random order i.e. data items can be read and written in any order. This is especially useful in direct access applications such as banking systems, airline reservation systems, Automatic Teller Machine (ATM) etc. where the desired information must be located immediately. Random access files (or direct access files) are analogous to arrays, where each element is accessed directly by means of its index number. Java provides java.io.RandomAccessFile class that enables you to perform random access file input and output operations as opposed to sequential file I/O offered by ByteStream and CharacterStream classes.

When a data file is opened for random read and write access, an internal file pointer is set at the beginning of the file. When you read or write data to the file, the file pointer moves forward to the next data item. For example, when reading an in t value using readlnt() , 4 bytes are read from the file and the file pointer moves 4 bytes ahead from the previous file pointer position.

Similarly, when reading a double value using readDouble () , 8 byte are read from the file pointer and the file pointer moves 8 bytes ahead from the previous file pointer position.

import java.io.*; 
 class RandomFileExample 
 { 
      public static void main(String[] args) 
     { 
           try 
           { 
           
               RandomAccessFile file = new RandomAccessFile("std.dat","rw");      
               file.setLength(0); 
               for(int i=0;i<50;i++) 
                    file.writeInt(i); 
                    System.out.println("Length of File After Writing Data is : "+file.length()); 
                    file.seek(0);  
                    System.out.println("First Number is : "+file.readInt()); 
                    file.seek(1*4); 
                    System.out.println("Second Number is : "+file.readInt()); 
                    file.writeInt(101); 
                    file.seek(file.length());  
                    file.writeInt(50); 
                    System.out.println("Current Length of File is : "+file.length()); 
           } 
                    catch(Exception e) 
                   { 
                         e.printStackTrace(); 
                   } 
     } 
 } 
 

Java also supports writing and reading objects to stream (such as a file). The process of reading and writing objects in a file is called object serialization. Writing an object to a file is called serializing the object and reading the object back from a file is called deserializing an object. In Java, serialization occurs automatically. Objects can be converted into a sequence of bytes, or serialized, by using the java.io.ObjectOutputStream class and they can be deserialized or converted from bytes into a structured object, by using java.io.ObjectlnputStream class.

import java.io.*; 
 class Employee implements Serializable 
 {       
      int empid; 
      String ename; 
      double salary;   
      Employee(int id,String name,double sal) 
      {       
        empid = id; 
        ename = name; 
        salary = sal; 
      } 
      void showInformation() 
      { 
        System.out.println("Empid : " + empid); 
        System.out.println("Empid : " + ename); 
        System.out.println("Salary : " + salary); 
        System.out.println(); 
      } 
 } 
       
 class ObjectIOStreamExample 
 { 
        public static void main(String[] args) 
        {           
            Employee empData[] = {new Employee(1,"Dinesh",50000), 
                              new Employee(2,"Shubhra",15000), 
                              new Employee(3,"Punar",26000) }; 
            try 
            {    
                 FileOutputStream fout = new FileOutputStream("std.dat"); 
                 ObjectOutputStream objOut = new ObjectOutputStream(fout); 
                 for(int i=0; i<empData.length;i++) 
                       objOut.writeObject(empData[i]); 
                       objOut.close(); 
            } 
            catch(Exception e){e.printStackTrace();} 
            try 
            {            
               FileInputStream fin = new FileInputStream("std.dat"); 
               ObjectInputStream objIn = new ObjectInputStream(fin);           
               Employee emp = (Employee) objIn.readObject(); 
               emp.showInformation(); 
               emp = (Employee) objIn.readObject(); 
               emp.showInformation(); 
               emp = (Employee) objIn.readObject(); 
               emp.showInformation();             
               objIn.close(); 
            } 
            catch(Exception e){e.printStackTrace();} 
         } 
 } 
 

The BufferedOutputStream class is a subclass of FilterOutputStream that stores written data in an internal buffer (a protected byte array field named buf) until the buffer is full or the stream is explicitly flushed using the flush ()method. Then it writes the data onto the underlying output stream all at once. This class does not declare any new methods of its own, rather all the methods are inherited from the OutputStream class.

The BufferedIntputStream class is a subclass of FilterlnputStream which reads as many data as possible into its internal buffer (a protected byte array field named buf) in a single read () call and then each read ()call reads data from the buffer instead of the underlying stream. When the buffer runs out of data, the buffered stream refills its buffer from the underlying stream. This class does not declare any new methods of its own, rather all the methods are inherited from the InputStream class.

import java.io.*; 
 class BufferIOStreamExample 
 { 
     public static void main(String[] args) 
     { 
       int ch; 
          try 
          { 
                 FileOutputStream fout=new FileOutputStream("std.dat"); 
                 BufferedOutputStream bout = new BufferedOutputStream(fout); 
                 for(int i=1;i<=10;i++) 
                      bout.write(i*i); 
                      bout.close(); 
           } 
                      catch(IOException e)  { e.printStackTrace(); } 
          try 
          { 
                      FileInputStream fin=new FileInputStream("std.dat"); 
                      BufferedInputStream bin = new BufferedInputStream(fin); 
                      while((ch=bin.read())!=-1) 
                      System.out.print(ch +" "); 
                      bin.close(); 
          } 
                      catch(IOException e)  { e.printStackTrace(); } 
     } 
 } 
 

When you need to process primitive types, Java provides DatalnputStream and DataOutputStream classes.

The DatalnputStream class is a subclass of FilterlnputStream that reads bytes from a stream and converts them into appropriate primitive type values or strings.

The DatalnputStream class implements the Datalnput interface that defines the methods for reading primitive types values or strings from a byte input stream.

import java.io.*; 
 class DataIOStreamExample 
 { 
     public static void main(String[] args) 
    { 
        try 
       { 
           
           FileOutputStream fin=new FileOutputStream ("Std.dat"); 
           DataOutputStream din = new DataOutputStream(fin); 
           din.writeInt(101); 
           din.writeUTF("Dinesh Thakur"); 
           din.writeDouble(99.5); 
           din.writeLong(98765432); 
           din.close(); 
        } 
           catch(IOException e)  { e.printStackTrace();}  
        try 
       { 
           FileInputStream fin=new FileInputStream("std.dat"); 
           DataInputStream din=new DataInputStream(fin); 
           System.out.println("Roll Number : " + din.readInt()); 
           System.out.println("Name : "+din.readUTF());       
           System.out.println("Percentage : "+ din.readDouble()); 
           System.out.println("Phone Number :"+  din.readLong()); 
           din.close(); 
        } 
           catch(IOException e)  { e.printStackTrace(); } 
     } 
 } 
 

In this Java Example in the main () method of the class FileIOStream, an instance fileOutput of FileOutputStream is created to write to the file mydata.dat. Then using the for loop, we write the square of the value stored in the index variable i using the write () method to the file mydata.dat. The output stream is then closed by calling the close () method.

In order to read bytes from the file mydata.dat, we create an instance filelnput of the FilelnputStream class. We then read the bytes from the mydata.dat file one by one and display it on the screen. For this, we use the while loop in which the expression

(ch = filelnput.read())!= -1

reads a byte from the input stream, assigns it to the variable ch and checks whether it is -1 or not. If it is not equal to -1 then the byte is displayed on the screen. If ch = -1 then it indicates that end of file (EOF) is reached and the loop terminates. Finally, the program closes the input stream and terminates.

import java.io.*; 
 class FileIOStream 
 { 
           public static void main(String[] args) 
       { 
              int ch;  
              try 
             {  
                  //Create an instance of the output statream 
                  FileOutputStream fileOutput = new FileOutputStream("mydata.dat"); 
                  //write data to the stream 
                 for(int i=1;i<=10;i++) 
                     fileOutput.write(i); 
                     fileOutput.close(); //close the output stream 
             } 
             catch(IOException e)   { e.printStackTrace(); } 
             try 
            { 
                 //Create an instance of the input stream 
                 FileInputStream fileInput=new FileInputStream("mydata.dat"); 
                 //reading data from a file, unil Eof is reached 
                 while((ch=fileInput.read())!= -1) 
                 System.out.print(ch + " "); 
                 fileInput.close(); //close the input stream 
            } 
            catch(IOException e)  { e.printStackTrace(); } 
       } 
 } 
 

In order in create File object, the File class provides the following constructors.

• File (String pathname): Creates a File object associated with the file or directory specified by pathname. The pathname can contain path information as well as a file or directory name.

To create an object for the file named HelloJavaExample.java in the current directory (java) in the Window OS, use the following statements.

For absolute path,

File file = new File(“C:\\java\\ HelloJavaExample.java”);

For relative path,

File file = new File(“HelloJavaExample.java”);

• File (File dir, String name) Creates a File object with the given file or directory name in the directory specified by the dir parameter of type File. If the dir parameter is null, this constructor then creates a File object using the current directory. For example, the statement

File dir = new File(“C:/java/classes”);

File f2 = new File(dir, ” HelloJavaExample.java”);

creates a File object f2 with the filename HelloJavaExample.java existing in the directory specified by File object dir.

import java.io.*; 
  class FileCreate 
  { 
             public static void main(String[] args) 
        { 
                  File file = new File("HelloJavaExample.java"); 
                  System.out.println("File Exists : "+file.exists()); 
                  System.out.println("Length of File is : "+file.length()); 
                  System.out.println("Can Read File : "+file.canRead()); 
                  System.out.println("Can Write to File : "+file.canWrite()); 
                  System.out.println("whether File is a Directory : "+file.isDirectory()); 
                  System.out.println("whether File is a File : "+file.isFile()); 
                  System.out.println("File name is : "+file.getName()); 
                  System.out.println("File absolute path is : "+file.getAbsolutePath()); 
                  System.out.println("File path is : "+file.getPath()); 
                  System.out.println("File parent directory is : "+file.getParent()); 
                  System.out.println("File last modified on : "+ new java.util.Date(file.lastModified())); 
   
         } 
 }