Cronometraje hecho fácilmente

package CronoMetro;

import java.util.HashMap;

/**
 * <p>Con ello la clase ayuda a calcular y a emitir fácilmente tiempos de
 * ejecuciones de aplicaciones.</p>
 * <p>Después de la instanciación el método arranque() debe ser llamado para definir un
 * tiempo de inicio. </p>
 * <p>Después de la terminación del programa se finaliza el cronometraje con fin(), después de esto
 * los valores del intervalo están disponibles:</p>
 * <p>El intervalo total convertido en</p>
 * <ul>
 * <li>Nanosegundos</li>
 * <li>Milisegundos</li>
 * <li>Segundos</li>
 * <li>Minutos</li>
 * <li>Horas</li>
 * <li>Días</li>
 * <li>El intervalo convertido legiblemente</li>
 * </ul>
 * @author Dominik Sust
 * @creation 07.07.2014 09:20:36
 * @version 1.0
 */
public class CronoMetro
{

    //Arranque y tiempo de finalización en nanosegundos
    private long startTime = 0L;
    private long endTime = 0L;

    //Intervalos
    private long intervalInNanoseconds;
    private double intervalInMilliseconds;
    private double intervalInSeconds;
    private double intervalInMinutes;
    private double intervalInHours;
    private double intervalInDays;

    //Intervalo total
    private HashMap<String, Integer> totalInterval = new HashMap<String, Integer>();

    /**
     * Arranca el cronometraje
     * Esa función puede ser llamada sólo una vez para que no pueda ocurrir un intervalo 
     * de tiempo negativo. Solo se registrará la primera llamada,
     * las llamadas posteriores serán ignoradas.
     */
    public void arranque()
    {
        if ( startTime == 0L )
        {
            startTime = System.nanoTime();
        }
    }

    /**
     * Finaliza el cronometraje. 
     * Esta función puede ser llamada varias veces para calcular varios 
     * (con medida a la primera llamada
     * arranque()).  Después de la llamada de este método los valores de los resultados están
     * disponibles.
     */
    public void fin()
    {
        endTime = System.nanoTime();
        calculaTiempos();
    }

    /**
     * Función interna que calcula todos los intervalos
     */
    private void calculaTiempos()
    {
        //Intervalos totales
        intervalInNanoseconds = endTime - startTime;
        intervalInMilliseconds = (double) intervalInNanoseconds / (double) 1000000;
        intervalInSeconds = intervalInMilliseconds / (double) 1000;
        intervalInMinutes = (double) intervalInSeconds / (double) 60;
        intervalInHours = intervalInMinutes / (double) 60;
        intervalInDays = intervalInHours / (double) 24;

        //Intervalos totales en días, horas, minutos, segundos
        double oneSecondInMS = 1000.0;
        double oneMinuteInMS = 60000.0;
        double oneHourInMS = 3600000.0;
        double oneDayInMS = 86400000.0;

        //Calcular días
        double tempInterval = intervalInMilliseconds;
        int temp = (int) (tempInterval / oneDayInMS);
        totalInterval.put( "Days", temp );
        //Quitar los días calculados del intervalo total
        tempInterval -= temp * oneDayInMS;

        //Calcular horas
        temp = (int) (tempInterval / oneHourInMS);
        totalInterval.put( "Hours", temp );
        //Quitar las horas calculados del intervalo total
        tempInterval -= temp * oneHourInMS;

        //Calcular minutos
        temp = (int) (tempInterval / oneMinuteInMS);
        totalInterval.put( "Minutes", temp );
        // Quitar los minutos calculados del intervalo total
        tempInterval -= temp * oneMinuteInMS;

        //Calcular segundos
        temp = (int) (tempInterval / oneSecondInMS);
        totalInterval.put( "Seconds", temp );
        //Quitar los segundos calculados del intervalo total
        tempInterval -= temp * oneSecondInMS;

        //¿¿Milisegundos??
        totalInterval.put( "Milliseconds", (int) tempInterval );
    }

    /**
     * Retorna el intervalo total en nanosegundos.
     * Esta función suministra solamente un valor válido después de que los métodos 
     * arranque() y fin() son llamados
     * @return El intervalo total en nanosegundos
     */
    public long getIntervalInNanoseconds()
    {
        return intervalInNanoseconds;
    }

    /**
     * Retorna el intervalo total en milisegundos.
     * Esta función suministra solamente un valor válido después de que los métodos
     * arranque() y fin() son llamados
     * @return El intervalo total en milisegundos
     */    
    public double getIntervalInMilliseconds()
    {
        return intervalInMilliseconds;
    }
    
    /**
     * Retorna el intervalo total en segundos.
     * Esta función suministra solamente un valor válido después de que los métodos
     * arranque() y fin() son llamados
     * @return El intervalo total en segundos
     */
    public double getIntervalInSeconds()
    {
        return intervalInSeconds;
    }
    
    /**
     * Retorna el intervalo total en minutos.
     * Esta función suministra solamente un valor válido después de que los métodos
     * arranque() y fin() son llamados
     * @return El intervalo total en minutos
     */
    public double getIntervalInMinutes()
    {
        return intervalInMinutes;
    }

    /**
     * Retorna el intervalo total en horas.
     * Esta función suministra solamente un valor válido después de que los métodos
     * arranque() y fin() son llamados
     * @return El intervalo total en horas
     */    
    public double getIntervalInHours()
    {
        return intervalInHours;
    }

    /**
     * Retorna el intervalo total en días.
     * Esta función suministra solamente un valor válido después de que los métodos
     * arranque() y fin() son llamados
     * @return El intervalo total en días
     */     
    public double getIntervalInDays()
    {
        return intervalInDays;
    }

    /**
     * <p>Retorna una Hashmap con los valores del intervalo.</p>
     * <p>Llaves son</p>
     * <ul>
     * <li>Days</li>
     * <li>Hours</li>
     * <li>Minutes</li>
     * <li>Seconds</li>
     * <li>Milliseconds</li>
     * </ul>
     * <p>Con eso se puede elaborar una salida individual del intervalo.</p>
     * @return HashMap<String, Integer> 
     */
    public HashMap<String, Integer> getTotalInterval()
    {
        return totalInterval;
    }

    /**
     * <p>Retorna el intervalo en forma de strings totales.</p> 
     * <p>Ejemplo:<br> 
     * 2 días, 4 horas, 40 minutos, 38 segundos, 456 milisegundos</p>
     * <p>Si no se necesita todos los valores se puede elaborar por medio del
     * metodo getTotalInterval() una propia salida.</p>
     *
     * @return El intervalo en forma de string
     */
    public String totalIntervalToString()
    {
        int d = totalInterval.get( "Days" );
        int h = totalInterval.get( "Hours" );
        int min = totalInterval.get( "Minutes" );
        int s = totalInterval.get( "Seconds" );
        int ms = totalInterval.get( "Milliseconds" );

        String result = d+" dia, "+h+" hora, "+min+" minuto, "+s+" segundo, "+ms+" milisegundo";

        
        //Días
        if ( d != 1 )
        {
            result = result.replace( "dia", "dias");
        }
        //Horas
        if ( h != 1 )
        {
            result = result.replace( "hora", "horas");
        }
        //Minutos
        if ( min != 1 )
        {
            result = result.replace( "minuto", "minutos");
        }
        //Segundos
        if ( s != 1 )
        {
            result = result.replace( "segundo", "segundos");
        }
        //Milisegundos
        if ( ms != 1 )
        {
            result = result.replace( "milisegundo", "milisegundos");
        }         

        return result;
    }

    /**
     * <p>Emite todos los valores del objeto en el siguiente orden:</p>
     * <ul>
     * <li>startTime</li>
     * <li>endTime</li>
     * <li>intervalInNanoseconds</li>
     * <li>intervalInMilliseconds</li>
     * <li>intervalInSeconds</li>
     * <li>intervalInMinutes</li>
     * <li>intervalInHours</li>
     * <li>intervalInDays</li>
     * <li>La salida del metodo totalIntervalToString()</li>
     * </ul>
     * @return String
     */
    @Override
    public String toString()
    {
        return "IntervalUtil{"
                + "startTime=" + startTime
                + ",\n endTime=" + endTime
                + ",\n intervallInNanoseconds=" + intervalInNanoseconds
                + ",\n intervallInMilliseconds=" + intervalInMilliseconds
                + ",\n intervallInSeconds=" + intervalInSeconds
                + ",\n intervallInMinutes=" + intervalInMinutes
                + ",\n intervallInHours=" + intervalInHours
                + ",\n intervallInDays=" + intervalInDays
                + ",\n " + totalIntervalToString() + "'}'";
    }

}

private long startTime = 0L;
    private List<Long> stopTimes = new ArrayList<>();

    public void arranque() {
        if (startTime == 0L) {
            startTime = System.nanoTime();
        }
    }

    public void fin() {
        stopTimes.add(System.nanoTime());
    }

    public long getFullInterval() {
        return stopTimes.get(stopTimes.size()-1) - startTime;
    }

public void arranque() {
    if (stopTimes.size() == 0) {
        stopTimes.add(System.nanoTime());
    }
}

public long getFullInterval() {
    return getInterval(0, stopTimes.size()-1);
}

public long getInterval(int from, int to) {
    return stopTimes.get(to) - stopTimes.get(from);
}