Hola gente,
quiero compartir con ustedes con gusto una pequeña clase que se escribió puesto que algunos necesitan a menudo tal funcionalidad.
Se trata de la clase CronoMetro, una cosa sencilla y pequeña que puede emitir el tiempo de ejecución de sus Apps/Programas (o una parte de sus Apps/Programas).
El proceder es imaginablemente fácil: al principio ustedes instancian un objeto de tipo CronoMetro. Al principio del cronometraje llaman al método arranque().
Al final del cronometraje llaman al metodo fin(). A partir de ese momento los datos estan disponibles para ustedes:
. Intervalo total en nanosegundos.
. Intervalo total en milisegundos.
. Intervalo total en segundos.
. Intervalo total en minutos.
. Intervalo total en horas.
. Intervalo total en días.
Por otra parte, una emisión estándar del intervalo en las unidades que están arriba así como una devolución de un Hashmap para poder ajustar esa emición como se desea.
Código:
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() + "'}'";
}
}
Autor: Dominik Sust
Muchos saludos
Adalher
Buen aporte, gracias.
En mi opinión yo lo hago innecesariamente complicado. En absoluto no es necesario calcular todo inmediatamente (más bien al contrario) en cada llamada de fin(). Algo en esta manera sería suficiente:
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;
}
Con eso, con cada llamada de fin(), se guarda la fecha y la hora. En la consulta de los valores pueden calcular cualquier intervalo en cualquier formato.
Al vector "startTime" todavía también se puede renunciar. El tiempo de inicio es muy simplemente la primera entrada en la lista.
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);
}
Excelente post!!!