Java I/O Tutorial

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  

OutputStream vs InputStream

The explanation of OutputStream and InputStream classes are given below:

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. Let's understand the working of Java OutputStream and InputStream by the figure given below.

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

OutputStream Hierarchy

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

InputStream Hierarchy

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

Java FileOutputStream Example 1: write byte

    import java.io.FileOutputStream;  
    public class FileOutputStreamExample {  
        public static void main(String args[]){    
               try{    
                 FileOutputStream fout=new FileOutputStream("D:\\testout.txt");    
                 fout.write(65);    
                 fout.close();    
                 System.out.println("success...");    
                }catch(Exception e){System.out.println(e);}    
          }    
    }  

Output:

Success...

The content of a text file testout.txt is set with the data A.

testout.txt

A

Java FileOutputStream example 2: write string

    import java.io.FileOutputStream;  
    public class FileOutputStreamExample {  
        public static void main(String args[]){    
               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...");    
                }catch(Exception e){System.out.println(e);}    
          }    
    }  

Output:

Success...

The content of a text file testout.txt is set with the data Welcome to javaTpoint.

testout.txt

Welcome to javaTpoint.

Java 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  

Java FileInputStream class methods

Java FileInputStream example 1: read 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);}    
             }    
            }  

Note: Before running the code, a text file named as "testout.txt" is required to be created. In this file, we are having following content:
Welcome to javatpoint.

After executing the above program, you will get a single character from the file which is 87 (in byte form). To see the text, you need to convert it into character.

Output:

W

Java FileInputStream example 2: read all characters

    package com.javatpoint;  
      
    import java.io.FileInputStream;  
    public class DataStreamExample {  
         public static void main(String args[]){    
              try{    
                FileInputStream fin=new FileInputStream("D:\\testout.txt");    
                int i=0;    
                while((i=fin.read())!=-1){    
                 System.out.print((char)i);    
                }    
                fin.close();    
              }catch(Exception e){System.out.println(e);}    
             }    
            }  

Output:

Welcome to javaTpoint

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. Let's see the syntax for adding the buffer in an OutputStream

    OutputStream os= new BufferedOutputStream(new FileOutputStream("D:\\IO Package\\testout.txt"));  

Java BufferedOutputStream class declaration

Let's see the declaration for Java.io.BufferedOutputStream class:

    public class BufferedOutputStream extends FilterOutputStream  

Java BufferedOutputStream class constructors

Java BufferedOutputStream class methods

Example of BufferedOutputStream class:

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.

    package com.javatpoint;  
    import java.io.*;  
    public class BufferedOutputStreamExample{    
    public static void main(String args[])throws Exception{    
         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");    
    }    
    }  

Output:

Success

testout.txt

Welcome to javaTpoint.

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 declaration

Let's see the declaration for Java.io.BufferedInputStream class:

     public class BufferedInputStream extends FilterInputStream  
 

Java BufferedInputStream class constructors

Java BufferedInputStream class methods

Example of Java BufferedInputStream

Let's see the simple example to read data of file using BufferedInputStream:

    package com.javatpoint;  
       
    import java.io.*;  
    public class BufferedInputStreamExample{    
     public static void main(String args[]){    
      try{    
        FileInputStream fin=new FileInputStream("D:\\testout.txt");    
        BufferedInputStream bin=new BufferedInputStream(fin);    
        int i;    
        while((i=bin.read())!=-1){    
         System.out.print((char)i);    
        }    
        bin.close();    
        fin.close();    
      }catch(Exception e){System.out.println(e);}    
     }    
    }  

Here, we are assuming that you have following data in "testout.txt" file:

javaTpoint

Output:

javaTpoint

Java SequenceInputStream Class

Java SequenceInputStream class is used to read data from multiple streams. It reads data sequentially (one by one).

Java SequenceInputStream Class declaration

Let's see the declaration for Java.io.SequenceInputStream class:

Constructors of SequenceInputStream class

Methods of SequenceInputStream class

Java SequenceInputStream Example

In this example, we are printing the data of two files testin.txt and testout.txt.

    package com.javatpoint;  
      
    import java.io.*;  
    class InputStreamExample {    
      public static void main(String args[])throws Exception{    
       FileInputStream input1=new FileInputStream("D:\\testin.txt");    
       FileInputStream input2=new FileInputStream("D:\\testout.txt");    
       SequenceInputStream inst=new SequenceInputStream(input1, input2);    
       int j;    
       while((j=inst.read())!=-1){    
        System.out.print((char)j);    
       }    
       inst.close();    
       input1.close();    
       input2.close();    
      }    
    }    

Here, we are assuming that you have two files: testin.txt and testout.txt which have following information:

testin.txt:

Welcome to Java IO Programming.

testout.txt:

It is the example of Java SequenceInputStream class.

After executing the program, you will get following output:

Output:

Welcome to Java IO Programming. It is the example of Java SequenceInputStream class.

Example that reads the data from two files and writes into another file

In this example, we are writing the data of two files testin1.txt and testin2.txt into another file named testout.txt.

    package com.javatpoint;  
      
    import java.io.*;    
    class Input1{    
      public static void main(String args[])throws Exception{    
       FileInputStream fin1=new FileInputStream("D:\\testin1.txt");    
       FileInputStream fin2=new FileInputStream("D:\\testin2.txt");    
       FileOutputStream fout=new FileOutputStream("D:\\testout.txt");      
       SequenceInputStream sis=new SequenceInputStream(fin1,fin2);    
       int i;    
       while((i=sis.read())!=-1)    
       {    
         fout.write(i);        
       }    
       sis.close();    
       fout.close();      
       fin1.close();      
       fin2.close();       
       System.out.println("Success..");  
      }    
    }    

Output:

Succeess...

testout.txt:

    Welcome to Java IO Programming. It is the example of Java SequenceInputStream class.  

SequenceInputStream example that reads data using enumeration

If we need to read the data from more than two files, we need to use Enumeration. Enumeration object can be obtained by calling elements() method of the Vector class. Let's see the simple example where we are reading the data from 4 files: a.txt, b.txt, c.txt and d.txt.

    package com.javatpoint;  
    import java.io.*;    
    import java.util.*;    
    class Input2{    
    public static void main(String args[])throws IOException{    
    //creating the FileInputStream objects for all the files    
    FileInputStream fin=new FileInputStream("D:\\a.txt");    
    FileInputStream fin2=new FileInputStream("D:\\b.txt");    
    FileInputStream fin3=new FileInputStream("D:\\c.txt");    
    FileInputStream fin4=new FileInputStream("D:\\d.txt");    
    //creating Vector object to all the stream    
    Vector v=new Vector();    
    v.add(fin);    
    v.add(fin2);    
    v.add(fin3);    
    v.add(fin4);              
    //creating enumeration object by calling the elements method    
    Enumeration e=v.elements();      
    //passing the enumeration object in the constructor    
    SequenceInputStream bin=new SequenceInputStream(e);    
    int i=0;      
    while((i=bin.read())!=-1){    
    System.out.print((char)i);    
    }     
    bin.close();    
    fin.close();    
    fin2.close();    
    }    
    }    

The a.txt, b.txt, c.txt and d.txt have following information:

a.txt:

Welcome

b.txt:

to

c.txt:

java

d.txt:

programming

Output:

Welcometojavaprogramming

Java ByteArrayOutputStream Class

ava ByteArrayOutputStream class is used to write common data into multiple files. In this stream, the data is written into a byte array which can be written to multiple streams later.

The ByteArrayOutputStream holds a copy of data and forwards it to multiple streams. The buffer of ByteArrayOutputStream automatically grows according to data.

Java ByteArrayOutputStream class declaration

Let's see the declaration for Java.io.ByteArrayOutputStream class:

    public class ByteArrayOutputStream extends OutputStream  

Java ByteArrayOutputStream class constructors

Methods of SequenceInputStream class

Java ByteArrayOutputStream class methods

Example of Java ByteArrayOutputStream

Let's see a simple example of java ByteArrayOutputStream class to write common data into 2 files: f1.txt and f2.txt.

    package com.javatpoint;  
    import java.io.*;  
    public class DataStreamExample {  
    public static void main(String args[])throws Exception{    
          FileOutputStream fout1=new FileOutputStream("D:\\f1.txt");    
          FileOutputStream fout2=new FileOutputStream("D:\\f2.txt");    
            
          ByteArrayOutputStream bout=new ByteArrayOutputStream();    
          bout.write(65);    
          bout.writeTo(fout1);    
          bout.writeTo(fout2);    
            
          bout.flush();    
          bout.close();//has no effect    
          System.out.println("Success...");    
         }    
        }   

Output:

Success...

f1.txt:

A

f2.txt:

A

Java ByteArrayInputStream Class

The ByteArrayInputStream is composed of two words: ByteArray and InputStream. As the name suggests, it can be used to read byte array as input stream.

Java ByteArrayInputStream class contains an internal buffer which is used to read byte array as stream. In this stream, the data is read from a byte array.

The buffer of ByteArrayInputStream automatically grows according to data.

Java ByteArrayInputStream class declaration

Let's see the declaration for Java.io.ByteArrayInputStream class:

    public class ByteArrayInputStream extends InputStream  

Java ByteArrayInputStream class constructors

Java ByteArrayInputStream class methods

Example of Java ByteArrayInputStream

Let's see a simple example of java ByteArrayInputStream class to read byte array as input stream.

    package com.javatpoint;  
    import java.io.*;  
    public class ReadExample {  
      public static void main(String[] args) throws IOException {  
        byte[] buf = { 35, 36, 37, 38 };  
        // Create the new byte array input stream  
        ByteArrayInputStream byt = new ByteArrayInputStream(buf);  
        int k = 0;  
        while ((k = byt.read()) != -1) {  
          //Conversion of a byte into character  
          char ch = (char) k;  
          System.out.println("ASCII value of Character is:" + k + "; Special character is: " + ch);  
        }  
      }  
    }  

Output:

ASCII value of Character is:35; Special character is: #
ASCII value of Character is:36; Special character is: $
ASCII value of Character is:37; Special character is: %
ASCII value of Character is:38; Special character is: &

Java DataOutputStream Class

Java DataOutputStream class allows an application to write primitive Java data types to the output stream in a machine-independent way.

Java application generally uses the data output stream to write data that can later be read by a data input stream.

Java DataOutputStream class declaration

Let's see the declaration for java.io.DataOutputStream class:

    public class DataOutputStream extends FilterOutputStream implements DataOutput  

Java DataOutputStream class methods

Example of DataOutputStream class

In this example, we are writing the data to a text file testout.txt using DataOutputStream class.

    package com.javatpoint;  
      
    import java.io.*;  
    public class OutputExample {  
        public static void main(String[] args) throws IOException {  
            FileOutputStream file = new FileOutputStream(D:\\testout.txt);  
            DataOutputStream data = new DataOutputStream(file);  
            data.writeInt(65);  
            data.flush();  
            data.close();  
            System.out.println("Succcess...");  
        }  
    }  

Output:

Succcess...

testout.txt:

A

Java DataInputStream Class

Java DataInputStream class allows an application to read primitive data from the input stream in a machine-independent way.

Java application generally uses the data output stream to write data that can later be read by a data input stream.

Java DataInputStream class declaration

Let's see the declaration for java.io.DataInputStream class:

    public class DataInputStream extends FilterInputStream implements DataInput  

Example of DataInputStream class

In this example, we are reading the data from the file testout.txt file.

    package com.javatpoint;  
    import java.io.*;    
    public class DataStreamExample {  
      public static void main(String[] args) throws IOException {  
        InputStream input = new FileInputStream("D:\\testout.txt");  
        DataInputStream inst = new DataInputStream(input);  
        int count = input.available();  
        byte[] ary = new byte[count];  
        inst.read(ary);  
        for (byte bt : ary) {  
          char k = (char) bt;  
          System.out.print(k+"-");  
        }  
      }  
    }  

Here, we are assuming that you have following data in "testout.txt" file:

JAVA

Output:

J-A-V-A

Java FilterOutputStream Class

Java FilterOutputStream class implements the OutputStream class. It provides different sub classes such as BufferedOutputStream and DataOutputStream to provide additional functionality. So it is less used individually.

Java FilterOutputStream class declaration

Let's see the declaration for java.io.FilterOutputStream class:

public class FilterOutputStream extends OutputStream 

Java FilterOutputStream class Methods

Example of FilterOutputStream class

    import java.io.*;  
    public class FilterExample {  
        public static void main(String[] args) throws IOException {  
            File data = new File("D:\\testout.txt");  
            FileOutputStream file = new FileOutputStream(data);  
            FilterOutputStream filter = new FilterOutputStream(file);  
            String s="Welcome to javaTpoint.";      
            byte b[]=s.getBytes();      
            filter.write(b);     
            filter.flush();  
            filter.close();  
            file.close();  
            System.out.println("Success...");  
        }  
    }  
       

Output:

Success...

testout.txt

Welcome to javaTpoint.

Java FilterInputStream Class

Java FilterInputStream class implements the InputStream. It contains different sub classes as BufferedInputStream, DataInputStream for providing additional functionality. So it is less used individually.

Java FilterInputStream class declaration

Let's see the declaration for java.io.FilterInputStream class

    public class FilterInputStream extends InputStream  

Java FilterInputStream class Methods

Methods	Description
int available()	It is used to return an estimate number of bytes that can be read from the input stream.
int read()	It is used to read the next byte of data from the input stream.
int read(byte[] b)	It is used to read up to byte.length bytes of data from the input stream.
long skip(long n)	It is used to skip over and discards n bytes of data from the input stream..
boolean markSupported()	It is used to test if the input stream support mark and reset method.
void mark(int readlimit)	It is used to mark the current position in the input stream.
void reset()	It is used to reset the input stream..
void close())	It is used to close the input stream.

Example of FilterInputStream class

    import java.io.*;  
    public class FilterExample {  
        public static void main(String[] args) throws IOException {  
            File data = new File("D:\\testout.txt");  
            FileInputStream  file = new FileInputStream(data);  
            FilterInputStream filter = new BufferedInputStream(file);  
            int k =0;  
            while((k=filter.read())!=-1){  
                System.out.print((char)k);  
            }  
            file.close();  
            filter.close();  
        }  
    }  

Here, we are assuming that you have following data in "testout.txt" file:

Welcome to javatpoint

Output:

Welcome to javatpoint

Java - ObjectStreamClass

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

Fields

Method

Example

    import java.io.ObjectStreamClass;  
    import java.util.Calendar;  
      
    public class ObjectStreamClassExample {  
        public static void main(String[] args) {  
      
            // create a new object stream class for Integers  
            ObjectStreamClass osc = ObjectStreamClass.lookup(SmartPhone.class);  
      
            // get the value field from ObjectStreamClass for integers  
            System.out.println("" + osc.getField("price"));  
      
            // create a new object stream class for Calendar  
            ObjectStreamClass osc2 = ObjectStreamClass.lookup(String.class);  
      
            // get the Class instance for osc2  
            System.out.println("" + osc2.getField("hash"));  
      
        }  
    }  

Output:

I price
null

Java ObjectStreamField class

A description of a Serializable field from a Serializable class. An array of ObjectStreamFields is used to declare the Serializable fields of a class.

The java.io.ObjectStreamClass.getField(String name) method gets the field of this class by name.

Constructor

Methods

public char getTypeCode()

Returns character encoding of field type. The encoding is as follows:

Returns:the typecode of the serializable field

Example:

    import java.io.ObjectStreamClass;  
    import java.util.Calendar;  
      
    public class ObjectStreamClassExample {  
         public static void main(String[] args) {  
                 
              // create a new object stream class for Integers  
              ObjectStreamClass osc = ObjectStreamClass.lookup(String.class);  
      
              // get the value field from ObjectStreamClass for integers  
              System.out.println("" + osc.getField("value"));  
      
              // create a new object stream class for Calendar  
              ObjectStreamClass osc2 = ObjectStreamClass.lookup(Calendar.class);  
      
              // get the Class instance for osc2  
              System.out.println("" + osc2.getField("isTimeSet"));  
      
           }  
    }  

Output:

I value
Z isTimeSet

Java Console Class

The Java Console class is be used to get input from console. It provides methods to read texts and passwords.

If you read password using Console class, it will not be displayed to the user.

The java.io.Console class is attached with system console internally. The Console class is introduced since 1.5.

Let's see a simple example to read text from console.

    String text=System.console().readLine();    
    System.out.println("Text is: "+text);    

Java Console class declaration

Let's see the declaration for Java.io.Console class:

    public final class Console extends Object implements Flushable  

Java Console class methods

How to get the object of Console

System class provides a static method console() that returns the singleton instance of Console class.

    public static Console console(){}   

Let's see the code to get the instance of Console class.

Console c=System.console();  

Java Console Example

    import java.io.Console;  
    class ReadStringTest{    
    public static void main(String args[]){    
    Console c=System.console();    
    System.out.println("Enter your name: ");    
    String n=c.readLine();    
    System.out.println("Welcome "+n);    
    }    
    }  

Output

Enter your name: Nakul Jain
Welcome Nakul Jain

Java Console Example to read password

    import java.io.Console;  
    class ReadPasswordTest{    
    public static void main(String args[]){    
    Console c=System.console();    
    System.out.println("Enter password: ");    
    char[] ch=c.readPassword();    
    String pass=String.valueOf(ch);//converting char array into string    
    System.out.println("Password is: "+pass);    
    }    
    }  

Output

Enter password: 
Password is: 123

Java FilePermission Class

Java FilePermission class contains the permission related to a directory or file. All the permissions are related with path. The path can be of two types:

1) D:\\IO\\-: It indicates that the permission is associated with all sub directories and files recursively.

2) D:\\IO\\*: It indicates that the permission is associated with all directory and files within this directory excluding sub directories

Java FilePermission class declaration

Let's see the declaration for Java.io.FilePermission class:

public final class FilePermission extends Permission implements Serializable 

Methods of FilePermission class

Java FilePermission class methods

Java FilePermission Example

Let's see the simple example in which permission of a directory path is granted with read permission and a file of this directory is granted for write permission.

    package com.javatpoint;  
      
    import java.io.*;  
    import java.security.PermissionCollection;  
    public class FilePermissionExample{  
           public static void main(String[] args) throws IOException {  
            String srg = "D:\\IO Package\\java.txt";  
            FilePermission file1 = new FilePermission("D:\\IO Package\\-", "read");  
            PermissionCollection permission = file1.newPermissionCollection();  
            permission.add(file1);  
                 FilePermission file2 = new FilePermission(srg, "write");  
                 permission.add(file2);  
                 if(permission.implies(new FilePermission(srg, "read,write"))) {  
                 System.out.println("Read, Write permission is granted for the path "+srg );  
                 }else {  
                System.out.println("No Read, Write permission is granted for the path "+srg);            }  
           }   
    }  

Output

Read, Write permission is granted for the path D:\IO Package\java.txt

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(). Most subclasses will override some of the methods defined here to provide higher efficiency, functionality or both.

Fields

Constructor

Methods

Java Writer Example

    import java.io.*;  
    public class WriterExample {  
        public static void main(String[] args) {  
            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();  
            }  
        }  
    }  

Output:

Done

output.txt:

I love my country