File Handling and Input/Output

java.io package

Classes related to input and output are present in the Java^TM language package java.io . Java technology uses "streams" as a general mechanism of handling data. Input streams act as a source of data. Output streams act as a destination of data.

File class

The file class is used to store the path and name of a directory or file. The file object can be used to create, rename, or delete the file or directory it represents. The File class has the following constructors - File(String pathname); // pathname could be file or a directory name File(String dirPathname, String filename); File(File directory, String filename); The File class provides the getName() method which returns the name of the file excluding the directory name. String getName();

Byte Streams

The package java.io provides two set of class hierarchies - one for handling reading and writing of bytes, and another for handling reading and writing of characters. The abstract classes InputStream and OutputStream are the root of inheritance hierarchies handling reading and writing of bytes respectively. Figure : InputStream class hierarchy (partial) Figure : OutputStream class hierarchy (partial)

read and write methods

InputStream class defines the following methods for reading bytes - int read() throws IOExceptionint read(byte b[]) throws IOExceptionint read(byte b[], int offset, int length) throws IOException Subclasses of InputStream implement the above mentioned methods. OutputStream class defines the following methods for writing bytes - void write(int b) throws IOExceptionvoid write(byte b[]) throws IOExceptionvoid write(byte b[], int offset, int length) throws IOException Subclasses of OutputStream implement the above mentioned methods. The example below illustrates code to read a character. //First create an object of type FileInputStream type using the name of the file.FileInputStream inp = new FileInputStream("filename.ext");//Create an object of type DataInputStream using inp.DataInputStream dataInp = new DataInputStream(inp);int i = dataInp.readInt();

Reader and Writer classes(l.w. = chr = character and last r = reader )

Similar to the InputStream and OutputStream class hierarchies for reading and writing bytes, Java technology provides class hierarchies rooted at Reader and Writer classes for reading and writing characters. A character encoding is a scheme for internal representation of characters. Java programs use 16 bit Unicode character encoding to represent characters internally. Other platforms may use a different character set (for example ASCII) to represent characters. The reader classes support conversions of Unicode characters to internal character shortage. Every platform has a default character encoding. Besides using default encoding, Reader and Writer classes can also specify which encoding scheme to use.The Reader class hierarchy is illustrated below. The Writer class hierarchy is illustrated below. The table below gives a brief overview of key Reader classes.

CharArrayReader	The class supports reading of characters from a character array.
InputStreamReader	The class supports reading of characters from a byte input stream. A character encoding may also be specified.
FileReader	The class supports reading of characters from a file using default character encoding.

The table below gives a brief overview of key Writer classes.

CharArrayWriter	The class supports writing of characters from a character array.
OutputStreamReader	The class supports writing of characters from a byte output stream. A character encoding may also be specified.
FileWriter	The class supports writing of characters from a file using default character encoding.

The example below illustrates reading of characters using the FileReader class. //Create a FileReader class from the file name.FileReader fr = new FileReader("filename.txt");int i = fr.read(); //Read a character

Threads

Threads

A thread is in process in execution within a program. Within a program each thread defines a separate path of execution.

Creation of a thread

A thread can be created in two ways a) By implementing the Runnable interface. The Runnable interface consists of only one method - the run method. The run method has a prototype of public void run(); b) By extending the class Thread.

Execution of a thread

To execute a thread, the thread is first created and then the start() method is invoked on the thread. Eventually the thread would execute and the run method would be invoked. The example below illustrates the two methods of thread creation. You should note that the run method should not be invoked directly.

public class ThreadExample extends Thread {
   public void run() {
      System.out.println("Thread started");
   }
   public static void main(String args[]) {
      ThreadExample t = new ThreadExample();
      t.start();
   }
}
Example - Creation of Thread by extending the 
Thread class.

When the run method ends, the thread is supposed to "die". The next example shows the creation of thread by implementing the Runnable interface.

public class ThreadExample2 implements Runnable {
   public void run() {
   .../* Code which gets executed when 
         thread gets executed. */
   }
   public static void main(String args[]) {
      ThreadExample2 Tt = new ThreadExample2();
      Thread t = new Thread(Tt);
      t.start();
   }
}

Example - Creating thread by implementing Runnable

States of thread

A thread can be in one of the following states - ready, waiting for some action, running, and dead. These states are explained below. Running State A thread is said to be in running state when it is being executed. This thread has access to CPU. Ready State A thread in this state is ready for execution, but is not being currently executed. Once a thread in the ready state gets access to the CPU, it gets converted to running state. Dead State A thread reaches "dead" state when the run method has finished execution. This thread cannot be executed now.Waiting State In this state the thread is waiting for some action to happen. Once that action happens, the thread gets into the ready state. A waiting thread can be in one of the following states - sleeping, suspended, blocked, waiting for monitor. These are explained below.

Yielding to other processes

A CPU intensive operation being executed may not allow other threads to be executed for a "large" period of time. To prevent this it can allow other threads to execute by invoking the yield() method. The thread on which yield() is invoked would move from running state to ready state.

Sleep state of a thread

A thread being executed can invoke the sleep() method to cease executing, and free up the CPU. This thread would go to the "sleep" state for the specified amount of time, after which it would move to the "ready" state. The sleep method has the following prototypes.

public static void sleep (long millisec) //sleep for millisec
            throws InterruptedException;
public static void sleep (long millisec, int nanosec) //sleep for x millisec
            throws InterruptedException;           // and y nanoseconds

Synchronized state

A code within the synchronized block is "atomic". This means only one thread can execute that block of code for a given object at a time. If a thread has started executing this block of code for an object, no other thread can execute this block of the code (or any other block of synchronized code) for the same object.

public synchronized void synchExample() {
   /* A set of synchronized statements. Assume 
      here that x is a data member of this class. */
   if(x == 0)
      x = 1;
}

Various Classes in Java technology

The Object class

All classes in Java^TM technology are directly or indirectly derived from the Object class. Some of the subclasses of Object class are - Boolean, Number, Void, Math, String, StringBuffer etc. Some of the important methods defined in the Object class are given below. These methods are available to all Java classes.

1. boolean equals(Object obj) - The equals method in Object class returns true if two references point to the same object. Some classes like String and Boolean overload this method. 
2. String toString() - The function is used to convert objects to String. If a subclass does not override this method, the method returns a textual representation of the object, which has the following format : @".
3. The following methods related to threads are also defined in Object class -
   void notify()
void notifyall()
void wait(long timeout) throws InteruptedException
void wait(long timeout, int nanosec) throws InteruptedException
void wait() throws InteruptedException


Wrapper classes

Corresponding to all the primitive types Java technology defines wrapper classes. Some examples of these wrapper classes are - Character, Boolean, Integer, Double.

Important methods in the Math class

Some of the methods defined in the Math class are used frequently. These are explained below. Besides the functionality, it is important to understand the arguments and return type of these functions.static double ceil(double(d)) : The method ceil returns the smallest double value equal to a mathematical integer, that is not less than the argument. For example,

ceil(3.4) returns 4.0

ceil(-2.3) returns -2.0

ceil(3.0) returns 3.0

static double floor(double(d)) : The method floor returns the largest double value equal to a mathematical integer, that is not greater than the argument. For example,

floor(3.4) returns 3.0

floor(-2.3) returns -3.0

floor(3.0) returns 3.0

static int round (float f) and static long round(double d) : The method round returns the integer closest to the argument.

round(3.7) returns 4

round(3.2) returns 3

round(3.0) returns 3

round(-3.1) returns -3

String class

The String class is used to implement immutable character strings. This means that the character string cannot be changed once it has been created. Some of the important methods are explained below.int length() - The number of characters in the String class are returned by the length() method. String substring(int startIndex) String substring(int startIndex, int endIndex) The method substring extracts a substring from a string. The method extracts a string from the startIndex to the index endIndex - 1. If endIndex is not specified then string till the end of input string is returned. The example below illustrates this

String str = "I am a string";

int len = str.length();

String str2 = str.substring(2,5);

After the above statements str2 contains the string "am ". The string str still has the same value "I am a string". The variable len has value 13.

StringBuffer class

The StringBuffer class implements mutable strings. This means that the characters stored in the string and the capacity of the string can be changed.

Garbage Collection

Java technology's Garbage collection is complex. In this section I am only giving a brief overview of Garbage Collection. Java technology supports automatic garbage collection. This means that the programmer does not need to free the memory used by objects. Java technology's runtime environment can claim the memory from the objects that are no longer in use. Objects that are not being referred become candidates for garbage collection. It is important to note that these objects are candidates only. Java technology does not guarantee that Garbage collection would happen on these objects. Before actually freeing up the memory, garbage collector invokes the finalize() method of the Object being freed. The System.gc() method can be invoked by the program to suggest to Java technology that the Garbage Collector be invoked. However there is no guarantee when the garbage collection would be invoked. There is also no guarantee on the order in which objects will be garbage collected. The example illustrates when a string Object becomes available for Garbage Collection.

public class GCTest {

public static void main(String args[]) {

String a,b;

String c = new String("test");

a = c;

c = null; // The String "test" is not yet 

//available for GC as a still points to "test"

b = new String("xyz");

b = c; // String "xyz" is now available for GC.

a = null; 

//String "test" is now available for GC.

}

}