Sunncity.com - Developer & I.T. Zone

Java Online Tutorial - THE JAVA IO PACKAGES
All about Input & Output Streams

A stream is a logical entity that either produces or consumes information. When sending a stream of data it is said that we are writing a stream. When receiving a stream of data we are said to be reading a stream.

If an error occurs when reading or writing a stream, an exception (usually IOException) is thrown. As a result, you must surround your stream statements with a try - catch block, in order to handle the exception.

The Java library classes for I/O are grouped together in a package called java.io.*. All classes that have anything to do with input inherit from InputStream and all classes that have anything to do with output inherit from OutputStream

The classes of the java.io hierarchy

• The classes of the java.io hierarchy
• The Byte array Input/Output Stream
• Concatenating two files and the Sequence Input/Output Streams
• The Buffered Input/Output Streams
• The Data Input/Output Streams
• The Piped Input/Output Streams

Readers and Writers

• The CharArrayReader and CharArrayWriter
• The StringReader and StringWriter
• The FileReader and FileWriter
• The LineNumberReader
• Random Access Files

The classes of the java.io hierarchy

• InputStream
  • FilterInputStream
    • BufferedInputStream
    • DataInputStream
    • LineNumberInputStream
    • PushbackInputStream
  • ByteArrayInputStream
  • FileInputStream
  • ObjectInputStream
  • PipedInputStream
  • SequenceInputStream
  • StringBufferInputStream
• OutputStream
  • FilterOutputStream
    • BufferedOutputStream
    • DataOutputStream
    • PrintStream
  • ByteArrayOutputStream
  • FileOutputStream
  • ObjectOutputStream
  • PipedOutputStream
• Reader
  • BufferedReader
    • LineNumberReader
  • CharArrayReader
  • FilterReader
    • PushbackReader
  • InputStreamReader
    • FileReader
  • PipedReader
  • StringReader
• Writer
  • BufferedWriter
  • CharArrayWriter
  • FilterWriter
  • OutputStreamWriter
    • FileWriter
  • PipedWriter
  • PrintWriter
  • StringWriter
• File
• RandomAccessFile
• FileDescriptor
• FilePermission
• ObjectStreamClass
• ObjectStreamField
• SerializablePermission
• StreamTokenizer

This may seem a little daunting at first but we shall take them one at a time and hopefully by the time you finish this chapter streams and their usage will become clearer to you. So let's get on with the examples.

Back to TOP

The Byte Array Input/Output Stream

import java.lang.System;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayIOApp {
 public static void main(String args[]) throws IOException {
  ByteArrayOutputStream outStream = new ByteArrayOutputStream();
  String s = "This is a test.";
  for(int i=0;i<s.length();++i)
     outstream.write(s.charAt(i));
  System.out.println("outstream:  " + outStream);
  System.out.println("size:  " + outStream.size());
  ByteArrayInputStream inStream;
  inStream = new ByteArrayInputStream(outStream.toByteArray());
  int inBytes = inStream.available();
  System.out.println("inStream has  " + inBytes + " available bytes");
  byte inBuf[] = new byte[inBytes];
  int bytesRead = inStream.read(inBuf, 0, inBytes);
  System.out.println(bytesRead + "  bytes were read" );
  System.out.println("They are:  " + new String(inBuf));
  }
}

Back to TOP

Concatenating two files and the Sequence Input/Output Streams

import java.lang.System;
import java.io.FileInputStream;
import java.io.SequenceInputStream;
import java.io.IOException;

public class SequenceIOApp {
 public static void main(String args[]) throws IOException {
  SequenceInputStream inStream;
  FileInputStream f1 = new FileInputStream("ByteArrayIOApp.java");
  FileInputStream f2 = new FileInputStream("FileIOApp.java");
  inStream = new SequenceInputStream(f1,f2);
  boolean eof = false;
  int byteCount = 0;
  while (!eof) {
   int c = inStream.read();
   if(c == -1) eof = true;
   else{
    System.out.print((char) c);
    ++byteCount;
   }
  }
  System.out.println(byteCount+" bytes were read");
  inStream.close();
  f1.close();
  f2.close();
 }
}

Back to TOP

The Buffered Input/Output Streams

import java.lang.System;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.SequenceInputStream;
import java.io.IOException;

public class BufferedIOApp {
 public static void main(String args[]) throws IOException {
  SequenceInputStream f3;
  FileInputStream f1 = new FileInputStream("ByteArrayIOApp.java");
  FileInputStream f2 = new FileInputStream("FileIOApp.java");
  f3 = new SequenceInputStream(f1,f2);
  BufferedInputStream inStream = new BufferedInputStream(f3);
  BufferedOutputStream outStream = new BufferedOutputStream(System.out);
  inStream.skip(500);
  boolean eof = false;
  int byteCount = 0;
  while (!eof) {
   int c = inStream.read();
   if(c == -1) eof = true;
   else{
    outStream.write((char) c);
    ++byteCount;
   }
  }
  String bytesRead = String.valueOf(byteCount);
  bytesRead+=" bytes were read\n";
  outStream.write(bytesRead.getBytes(),0,bytesRead.length());
  inStream.close();
  outStream.close();
  f1.close();
  f2.close();
 }
}

Back to TOP

The Data Input/Output Streams

import java.lang.System;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;

public class DataIOApp {
 public static void main(String args[]) throws IOException {
  File file = new File("test.txt");
  FileOutputStream outFile = new FileOutputStream(file);
  DataOutputStream outStream = new DataOutputStream(outFile);
  outStream.writeBoolean(true);
  outStream.writeInt(123456);
  outStream.writeChar('j');
  outStream.writeDouble(1234.56);
  System.out.println(outStream.size()+" bytes were written");
  outStream.close();
  outFile.close();
  FileInputStream inFile = new FileInputStream(file);
  DataInputStream inStream = new DataInputStream(inFile);
  System.out.println(inStream.readBoolean());
  System.out.println(inStream.readInt());
  System.out.println(inStream.readChar());
  System.out.println(inStream.readDouble());
  inStream.close();
  inFile.close();
  file.delete();
 }
}

Back to TOP

The Piped Input/Output Streams

import java.lang.Thread;
import java.lang.System;
import java.lang.InterruptedException;
import java.lang.Runnable;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.IOException;

class PipedIOApp {
public static void main(String args[]) {
  Thread thread1 = new Thread(new PipeOutput("Producer"));
  Thread thread2 = new Thread(new PipeInput("Consumer"));
  thread1.start();
  thread2.start();
  boolean thread1IsAlive = true;
  boolean thread2IsAlive = true;
  do {
   if(thread1IsAlive && !thread1.isAlive()){
    thread1IsAlive = false;
    System.out.println("Thread 1 is dead.");
   }
   if(thread2IsAlive && !thread2.isAlive()){
    thread2IsAlive = false;
    System.out.println("Thread 2 is dead.");
   }
  }while(thread1IsAlive || thread2IsAlive);
}
}
class PipeIO {
static PipedOutputStream outputPipe = new PipedOutputStream();
static PipedInputStream inputPipe = new PipedInputStream();
static {
  try {
   outputPipe.connect(inputPipe);
  }catch (IOException ex) {
   System.out.println("IOException in static initializer");
  }
}
String name;
public PipeIO(String id) {
  name = id;
}
}
class PipeOutput extends PipeIO implements Runnable {
public PipeOutput(String id) {
  super(id);
}
public void run() {
  String s = "This is a test.";
  try {
   for(int i=0;i<s.length();++i){
    outputPipe.write(s.charAt(i));
    System.out.println(name+" wrote "+s.charAt(i));
   }
   outputPipe.write('!');
  } catch(IOException ex) {
   System.out.println("IOException in PipeOutput");
  }
}
}
class PipeInput extends PipeIO implements Runnable {
public PipeInput(String id) {
  super(id);
}
public void run() {
  boolean eof = false;
  try {
   while (!eof) {
    int inChar = inputPipe.read();
    if(inChar != -1) {
     char ch = (char) inChar;
     if(ch=='!'){
      eof=true;
      break;
     }else System.out.println(name+" read "+ch);
    }
   }
  } catch(IOException ex) {
   System.out.println("IOException in PipeOutput");
  }
}
}

Back to TOP

Readers and Writers
The CharArrayReader and CharArrayWriter

import java.lang.System;
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.IOException;

public class CharArrayIOApp {
 public static void main(String args[]) throws IOException {
  CharArrayWriter outStream = new CharArrayWriter();
  String s = "This is a test.";
  for(int i=0;i;<s.length();++i)
   outStream.write(s.charAt(i));
  System.out.println("outstream: "+outStream);
  System.out.println("size: "+outStream.size());
  CharArrayReader inStream;
  inStream = new CharArrayReader(outStream.toCharArray());
  int ch=0;
  StringBuffer sb = new StringBuffer("");
  while((ch = inStream.read()) != -1)
   sb.append((char) ch);
  s = sb.toString();
  System.out.println(s.length()+" characters were read");
  System.out.println("They are: "+s);
 }
}

Back to TOP

The StringReader and StringWriter

import java.lang.System;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.IOException;

public class StringIOApp {
 public static void main(String args[]) throws IOException {
  StringWriter outStream = new StringWriter();
  String s = "This is a test.";
  for(int i=0;i;<s.length();++i)
   outStream.write(s.charAt(i));
  System.out.println("outstream: "+outStream);
  System.out.println("size: "+outStream.toString().length());
  StringReader inStream;
  inStream = new StringReader(outStream.toString());
  int ch=0;
  StringBuffer sb = new StringBuffer("");
  while((ch = inStream.read()) != -1)
   sb.append((char) ch);
  s = sb.toString();
  System.out.println(s.length()+" characters were read");
  System.out.println("They are: "+s);
 }
}

Back to TOP

The FileReader and FileWriter

import java.lang.System;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.File;
import java.io.IOException;

public class CharFileIOApp {
 public static void main(String args[]) throws IOException {
  FileWriter outStream = new FileWriter("test.txt");
  String s = "This is a test.";
  for(int i=0;i;<s.length();++i)
   outStream.write(s.charAt(i));
  outStream.close();
  FileReader inStream = new FileReader("test.txt");
  StringBuffer sb = new StringBuffer("");
  int ch=0;
  while((ch = inStream.read()) != -1)
   sb.append((char) ch);
  s = sb.toString();
  System.out.println(s.length()+" characters were read");
  System.out.println("They are: "+s);
  inStream.close();
  File f = new File("test.txt");
  f.delete();
 }
}

Back to TOP

The LineNumberReader

import java.lang.System;
import java.io.LineNumberReader;
import java.io.FileReader;
import java.io.BufferedWriter;
import java.io.IOException;

public class LineNumberIOApp {
 public static void main(String args[]) throws IOException {
  FileReader inFile = new FileReader("LineNumberIOApp.java");
  LineNumberReader inLines = new LineNumberReader(inFile);
  String inputLine;
  while ((inputLine=inLines.readLine()) != null) {
   System.out.println(inLines.getLineNumber()+". "+inputLine);
  }
 }
}

Random Access Files

import java.lang.System;
import java.io.RandomAccessFile;
import java.io.IOException;

public class RandomIOApp {
 public static void main(String args[]) throws IOException {
  RandomAccessFile file = new RandomAccessFile("test.txt","rw");
  file.writeBoolean(true);
  file.writeInt(123456);
  file.writeChar('j');
  file.writeDouble(1234.56);
  file.seek(1);
  System.out.println(file.readInt());
  System.out.println(file.readChar());
  System.out.println(file.readDouble());
  file.seek(0);
  System.out.println(file.readBoolean());
  file.close();
 }
}

For a zip file containing all the examples for this chapter. Go here.

Back to TOP

Now on to the next chapter Multithreading

All questions and comments can be addressed to the author.
All material appearing within this website is copyright protected and may not be reproduced elsewhere without the express written permission of the author (Sanjeev Dasgupta)