Presents your 
JAVA E-NEWSLETTER for October 17, 2002

<------------------------------------------->

TIMESTAMP WITH THE STOPWATCH CLASS

Debuggers are heavy clunky things and not always the most effective
method available; sometimes, you want to add just a little bit of debugging
and profiling to some code. One solution is to output timestamps with 
the help of a nice simple StopWatch class.

package com.generationjava.test;

/**
 * Useful when doing timings in a debug or test situation.
 */
public class StopWatch {

    static public int AN_HOUR = 60 * 60 * 1000;
    static public int A_MINUTE = 60 * 1000;

    private long startTime = -1;
    private long stopTime = -1;
    
    /**
     * Start the stopwatch.
     */
    public void start() {
        this.startTime = System.currentTimeMillis();
    }
    
    /**
     * Stop the stopwatch.
     */
    public void stop() {
        this.stopTime = System.currentTimeMillis();
    }

    /**
     * Reset the stopwatch.
     */
    public void reset() {
        this.startTime = -1;
        this.stopTime = -1;
    }
        
    /**
     * Split the time.
     */
    public void split() {
        this.stopTime = System.currentTimeMillis();
    }

    /**
     * Remove a split.
     */
    public void unsplit() {
        this.stopTime = -1;
    }
    
    /**
     * Get the time on the stopwatch. This is either the
     * time between start and latest split, between start and stop,
     * or the time between the start and the moment this method is called.
     */
    public long getTime() {
        if(stopTime != -1) {
            return (System.currentTimeMillis() - this.startTime);
        } else {
            return this.stopTime - this.startTime;
        }
    }
    
    public String toString() {
        return getTimeString();
    }
    
    /**
     * Get the time gap as a String.
     * In hours, minutes, seconds and milliseconds.
     */
    public String getTimeString() {
        int hours, minutes, seconds, milliseconds;
        long time = getTime();
        hours = (int) (time / AN_HOUR);
        time = time - (hours * AN_HOUR);
        minutes = (int) (time / A_MINUTE);
        time = time - (minutes * A_MINUTE);
        seconds = (int) (time / 1000);
        time = time - (seconds * 1000);
        millis = (int) time;
 
        return hours + "h:" + minutes + "m:" + seconds + "s:" + millis + "ms";
    }      
}

While that's a fair chunk of code, it's all very simple. It does just
enough to make it reusable and nowhere near enough to make it complex.
Using the StopWatch class is therefore very simple:

StopWatch obj = new StopWatch();
obj.start();
try {
    Thread.currentThread().sleep(1500);
} catch(InterruptedException ie) {
    // ignore
}
obj.stop();
System.out.println(obj);

We sleep for 1500 milliseconds, or 1.5 seconds, and unsurprisingly, the
StopWatch reports:

0h:0m:1s:502ms

The StopWatch class is not rocket science, but it does help to satisfy 
a common need--to measure small lengths of time between lines of code.

----------------------------------------


CORRECTION

In the Oct. 17, 2002 TechMail ("Timestamp with the StopWatch class"), 
we
told you how to use a simple StopWatch class to output timestamps. Part
of the sample code for getting the time on the stopwatch contained an
error. The code read originally as:

public long getTime() {
         if(stopTime !== -1) {
             return (System.currentTimeMillis() - this.startTime);
         } else {
             return this.stopTime - this.startTime;
         }
     }

However, the code should read:

public long getTime() {
         if(stopTime == -1) {
             return (System.currentTimeMillis() - this.startTime);
         } else {
             return this.stopTime - this.startTime;
         }
     }

----------------------------------------