Cronometraje hecho fácilmente

  • 2 Respuestas
  • 470 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Conectado Adalher

  • *
  • Underc0der
  • Mensajes: 105
  • Actividad:
    63.33%
  • Reputación 0
    • Ver Perfil

Cronometraje hecho fácilmente

  • en: Agosto 29, 2019, 05:37:57 am
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:
Código: Java
  1. package CronoMetro;
  2.  
  3. import java.util.HashMap;
  4.  
  5. /**
  6.  * <p>Con ello la clase ayuda a calcular y a emitir fácilmente tiempos de
  7.  * ejecuciones de aplicaciones.</p>
  8.  * <p>Después de la instanciación el método arranque() debe ser llamado para definir un
  9.  * tiempo de inicio. </p>
  10.  * <p>Después de la terminación del programa se finaliza el cronometraje con fin(), después de esto
  11.  * los valores del intervalo están disponibles:</p>
  12.  * <p>El intervalo total convertido en</p>
  13.  * <ul>
  14.  * <li>Nanosegundos</li>
  15.  * <li>Milisegundos</li>
  16.  * <li>Segundos</li>
  17.  * <li>Minutos</li>
  18.  * <li>Horas</li>
  19.  * <li>Días</li>
  20.  * <li>El intervalo convertido legiblemente</li>
  21.  * </ul>
  22.  * @author Dominik Sust
  23.  * @creation 07.07.2014 09:20:36
  24.  * @version 1.0
  25.  */
  26. public class CronoMetro
  27. {
  28.  
  29.     //Arranque y tiempo de finalización en nanosegundos
  30.     private long startTime = 0L;
  31.     private long endTime = 0L;
  32.  
  33.     //Intervalos
  34.     private long intervalInNanoseconds;
  35.     private double intervalInMilliseconds;
  36.     private double intervalInSeconds;
  37.     private double intervalInMinutes;
  38.     private double intervalInHours;
  39.     private double intervalInDays;
  40.  
  41.     //Intervalo total
  42.     private HashMap<You are not allowed to view links. Register or Login, Integer> totalInterval = new HashMap<You are not allowed to view links. Register or Login, Integer>();
  43.  
  44.     /**
  45.      * Arranca el cronometraje
  46.      * Esa función puede ser llamada sólo una vez para que no pueda ocurrir un intervalo
  47.      * de tiempo negativo. Solo se registrará la primera llamada,
  48.      * las llamadas posteriores serán ignoradas.
  49.      */
  50.     public void arranque()
  51.     {
  52.         if ( startTime == 0L )
  53.         {
  54.             startTime = You are not allowed to view links. Register or Login.nanoTime();
  55.         }
  56.     }
  57.  
  58.     /**
  59.      * Finaliza el cronometraje.
  60.      * Esta función puede ser llamada varias veces para calcular varios
  61.      * (con medida a la primera llamada
  62.      * arranque()).  Después de la llamada de este método los valores de los resultados están
  63.      * disponibles.
  64.      */
  65.     public void fin()
  66.     {
  67.         endTime = You are not allowed to view links. Register or Login.nanoTime();
  68.         calculaTiempos();
  69.     }
  70.  
  71.     /**
  72.      * Función interna que calcula todos los intervalos
  73.      */
  74.     private void calculaTiempos()
  75.     {
  76.         //Intervalos totales
  77.         intervalInNanoseconds = endTime - startTime;
  78.         intervalInMilliseconds = (double) intervalInNanoseconds / (double) 1000000;
  79.         intervalInSeconds = intervalInMilliseconds / (double) 1000;
  80.         intervalInMinutes = (double) intervalInSeconds / (double) 60;
  81.         intervalInHours = intervalInMinutes / (double) 60;
  82.         intervalInDays = intervalInHours / (double) 24;
  83.  
  84.         //Intervalos totales en días, horas, minutos, segundos
  85.         double oneSecondInMS = 1000.0;
  86.         double oneMinuteInMS = 60000.0;
  87.         double oneHourInMS = 3600000.0;
  88.         double oneDayInMS = 86400000.0;
  89.  
  90.         //Calcular días
  91.         double tempInterval = intervalInMilliseconds;
  92.         int temp = (int) (tempInterval / oneDayInMS);
  93.         totalInterval.put( "Days", temp );
  94.         //Quitar los días calculados del intervalo total
  95.         tempInterval -= temp * oneDayInMS;
  96.  
  97.         //Calcular horas
  98.         temp = (int) (tempInterval / oneHourInMS);
  99.         totalInterval.put( "Hours", temp );
  100.         //Quitar las horas calculados del intervalo total
  101.         tempInterval -= temp * oneHourInMS;
  102.  
  103.         //Calcular minutos
  104.         temp = (int) (tempInterval / oneMinuteInMS);
  105.         totalInterval.put( "Minutes", temp );
  106.         // Quitar los minutos calculados del intervalo total
  107.         tempInterval -= temp * oneMinuteInMS;
  108.  
  109.         //Calcular segundos
  110.         temp = (int) (tempInterval / oneSecondInMS);
  111.         totalInterval.put( "Seconds", temp );
  112.         //Quitar los segundos calculados del intervalo total
  113.         tempInterval -= temp * oneSecondInMS;
  114.  
  115.         //¿¿Milisegundos??
  116.         totalInterval.put( "Milliseconds", (int) tempInterval );
  117.     }
  118.  
  119.     /**
  120.      * Retorna el intervalo total en nanosegundos.
  121.      * Esta función suministra solamente un valor válido después de que los métodos
  122.      * arranque() y fin() son llamados
  123.      * @return El intervalo total en nanosegundos
  124.      */
  125.     public long getIntervalInNanoseconds()
  126.     {
  127.         return intervalInNanoseconds;
  128.     }
  129.  
  130.     /**
  131.      * Retorna el intervalo total en milisegundos.
  132.      * Esta función suministra solamente un valor válido después de que los métodos
  133.      * arranque() y fin() son llamados
  134.      * @return El intervalo total en milisegundos
  135.      */    
  136.     public double getIntervalInMilliseconds()
  137.     {
  138.         return intervalInMilliseconds;
  139.     }
  140.    
  141.     /**
  142.      * Retorna el intervalo total en segundos.
  143.      * Esta función suministra solamente un valor válido después de que los métodos
  144.      * arranque() y fin() son llamados
  145.      * @return El intervalo total en segundos
  146.      */
  147.     public double getIntervalInSeconds()
  148.     {
  149.         return intervalInSeconds;
  150.     }
  151.    
  152.     /**
  153.      * Retorna el intervalo total en minutos.
  154.      * Esta función suministra solamente un valor válido después de que los métodos
  155.      * arranque() y fin() son llamados
  156.      * @return El intervalo total en minutos
  157.      */
  158.     public double getIntervalInMinutes()
  159.     {
  160.         return intervalInMinutes;
  161.     }
  162.  
  163.     /**
  164.      * Retorna el intervalo total en horas.
  165.      * Esta función suministra solamente un valor válido después de que los métodos
  166.      * arranque() y fin() son llamados
  167.      * @return El intervalo total en horas
  168.      */    
  169.     public double getIntervalInHours()
  170.     {
  171.         return intervalInHours;
  172.     }
  173.  
  174.     /**
  175.      * Retorna el intervalo total en días.
  176.      * Esta función suministra solamente un valor válido después de que los métodos
  177.      * arranque() y fin() son llamados
  178.      * @return El intervalo total en días
  179.      */    
  180.     public double getIntervalInDays()
  181.     {
  182.         return intervalInDays;
  183.     }
  184.  
  185.     /**
  186.      * <p>Retorna una Hashmap con los valores del intervalo.</p>
  187.      * <p>Llaves son</p>
  188.      * <ul>
  189.      * <li>Days</li>
  190.      * <li>Hours</li>
  191.      * <li>Minutes</li>
  192.      * <li>Seconds</li>
  193.      * <li>Milliseconds</li>
  194.      * </ul>
  195.      * <p>Con eso se puede elaborar una salida individual del intervalo.</p>
  196.      * @return HashMap<String, Integer>
  197.      */
  198.     public HashMap<You are not allowed to view links. Register or Login, Integer> getTotalInterval()
  199.     {
  200.         return totalInterval;
  201.     }
  202.  
  203.     /**
  204.      * <p>Retorna el intervalo en forma de strings totales.</p>
  205.      * <p>Ejemplo:<br>
  206.      * 2 días, 4 horas, 40 minutos, 38 segundos, 456 milisegundos</p>
  207.      * <p>Si no se necesita todos los valores se puede elaborar por medio del
  208.      * metodo getTotalInterval() una propia salida.</p>
  209.      *
  210.      * @return El intervalo en forma de string
  211.      */
  212.     public You are not allowed to view links. Register or Login totalIntervalToString()
  213.     {
  214.         int d = totalInterval.get( "Days" );
  215.         int h = totalInterval.get( "Hours" );
  216.         int min = totalInterval.get( "Minutes" );
  217.         int s = totalInterval.get( "Seconds" );
  218.         int ms = totalInterval.get( "Milliseconds" );
  219.  
  220.         You are not allowed to view links. Register or Login result = d+" dia, "+h+" hora, "+min+" minuto, "+s+" segundo, "+ms+" milisegundo";
  221.  
  222.        
  223.         //Días
  224.         if ( d != 1 )
  225.         {
  226.             result = result.replace( "dia", "dias");
  227.         }
  228.         //Horas
  229.         if ( h != 1 )
  230.         {
  231.             result = result.replace( "hora", "horas");
  232.         }
  233.         //Minutos
  234.         if ( min != 1 )
  235.         {
  236.             result = result.replace( "minuto", "minutos");
  237.         }
  238.         //Segundos
  239.         if ( s != 1 )
  240.         {
  241.             result = result.replace( "segundo", "segundos");
  242.         }
  243.         //Milisegundos
  244.         if ( ms != 1 )
  245.         {
  246.             result = result.replace( "milisegundo", "milisegundos");
  247.         }        
  248.  
  249.         return result;
  250.     }
  251.  
  252.     /**
  253.      * <p>Emite todos los valores del objeto en el siguiente orden:</p>
  254.      * <ul>
  255.      * <li>startTime</li>
  256.      * <li>endTime</li>
  257.      * <li>intervalInNanoseconds</li>
  258.      * <li>intervalInMilliseconds</li>
  259.      * <li>intervalInSeconds</li>
  260.      * <li>intervalInMinutes</li>
  261.      * <li>intervalInHours</li>
  262.      * <li>intervalInDays</li>
  263.      * <li>La salida del metodo totalIntervalToString()</li>
  264.      * </ul>
  265.      * @return String
  266.      */
  267.     @Override
  268.     public You are not allowed to view links. Register or Login toString()
  269.     {
  270.         return "IntervalUtil{"
  271.                 + "startTime=" + startTime
  272.                 + ",\n endTime=" + endTime
  273.                 + ",\n intervallInNanoseconds=" + intervalInNanoseconds
  274.                 + ",\n intervallInMilliseconds=" + intervalInMilliseconds
  275.                 + ",\n intervallInSeconds=" + intervalInSeconds
  276.                 + ",\n intervallInMinutes=" + intervalInMinutes
  277.                 + ",\n intervallInHours=" + intervalInHours
  278.                 + ",\n intervallInDays=" + intervalInDays
  279.                 + ",\n " + totalIntervalToString() + "'}'";
  280.     }
  281.  
  282. }
  283.  

Autor: Dominik Sust

Muchos saludos

Adalher
« Última modificación: Agosto 29, 2019, 12:57:39 pm por Denisse »

Conectado tr0n

  • *
  • Underc0der
  • Mensajes: 63
  • Actividad:
    43.33%
  • Reputación 3
    • Ver Perfil
    • Chat Latino

Re:Cronometraje hecho fácilmente

  • en: Agosto 29, 2019, 08:47:30 pm
Buen aporte, gracias.

Conectado Adalher

  • *
  • Underc0der
  • Mensajes: 105
  • Actividad:
    63.33%
  • Reputación 0
    • Ver Perfil

Re:Cronometraje hecho fácilmente

  • en: Septiembre 01, 2019, 05:26:09 pm
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:

Código: Java
  1. private long startTime = 0L;
  2.     private List<Long> stopTimes = new ArrayList<>();
  3.  
  4.     public void arranque() {
  5.         if (startTime == 0L) {
  6.             startTime = You are not allowed to view links. Register or Login.nanoTime();
  7.         }
  8.     }
  9.  
  10.     public void fin() {
  11.         stopTimes.add(You are not allowed to view links. Register or Login.nanoTime());
  12.     }
  13.  
  14.     public long getFullInterval() {
  15.         return stopTimes.get(stopTimes.size()-1) - startTime;
  16.     }
  17.  
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.
       
Código: Java
  1. public void arranque() {
  2.     if (stopTimes.size() == 0) {
  3.         stopTimes.add(You are not allowed to view links. Register or Login.nanoTime());
  4.     }
  5. }
  6.  
  7. public long getFullInterval() {
  8.     return getInterval(0, stopTimes.size()-1);
  9. }
  10.  
  11. public long getInterval(int from, int to) {
  12.     return stopTimes.get(to) - stopTimes.get(from);
  13. }
  14.