Segundos para medianoche: Calculando tiempos en Java

Estándar

Uno de los detalles que posiblemente halla notado si a manejado fechas en Java es que la forma mas comun de obtener la fecha y hora actual pasar la salida del método getTimeInMillis() de la clase Calendar a un objecto Date, y tal vez se halla preguntado por que. La explicación es bastante sencilla, una de las formas estandar de almacenar el tiempo en sistemas de computo es almacenando los milisegundos desde la llamada fecha UNIX, el primero de Enero de 1970, esto se hace ya que es mucho mas eficiente hacer los calculos temporales de ese modo ya que se reducen a sumar y restas cosa que las computadoras pueden hacer de forma muy efectiva. Como un ejemplo sencillo hagamos algo que puede ser util, calculemos cuanto tiempo falta para medianoche (esto sera útil en una entrada futura 😉 ) la forma en que haremos esto es bastante sencilla. Algoritmo para presentar en horas, minutos y segundos el tiempo hasta medianoche es el siguiente

  1. Crearemos un objecto calendario en el cual estableceremos las 00:00:00 del dia siguiente
  2. Convertinermos esa fecha a milisegundos y almacenaremos en una variable long
  3. Obtendremos los milisegundos de la fecha actual y lo almacenaremos en un long
  4. Sacaremos la diferencia entre los milisegundos de la medianoche y los de la hora actual
  5. Dividiremos esa diferencia entre 1000*60*60 para obtener las horas
  6. Obtendremos el modulo de esa división y lo almacenaremos en minutosMillis
  7. Dividiremos minutosMillis entre 1000*60 para obtener los minutos
  8. Obtendremos el modulo de esa division y lo almacenaremos en segundosMillis
  9. Dividiremos segundosMillis entre 1000 y obtendremos los segundos
  10. Presentaremos las horas, minutos y segundos en pantalla

Si su curso de programación fue hace suficiente tiempo tal vez ya no recuerde la operación modulo, esta es básicamente el residuo de la división entera y recordemos que el tipo long del java es básicamente un tipo de entero. La idea aqui es ir de la unidad mayor (las horas) a la menor (los segundos) usando el resultado de la division para sacar esa unidad y el residuo o modulo para calcular la siguiente, el código se ve a continuación:

package tiempo;

import java.util.Calendar;

public class Tiempo {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
//Creamos un objecto calendario
Calendar calendario = Calendar.getInstance();

long horas;
long minutos;
long segundos;
long milisegundos;

//Establecemos la fecha del calendario, las 00:00:00: del siguiente dia
calendario.add(Calendar.DAY_OF_MONTH, 1);
calendario.set(Calendar.HOUR_OF_DAY, 0);
calendario.set(Calendar.MINUTE, 0);
calendario.set(Calendar.SECOND, 0);
calendario.set(Calendar.MILLISECOND, 0);

// Obtenemos la fecha hora actual en milisegundos
long horaActual = System.currentTimeMillis();
// Obtenemos los milisegundos de la proxima medianoche
long howMany = calendario.getTimeInMillis();

// Cuandos milisegundos har de siferencia
milisegundos = howMany – horaActual;
System.out.println(“MiliSegundos para media noche: “
+ (milisegundos));

// Calculamos las horas
horas = milisegundos / (1000 * 60 * 60);
System.out.println(“Horas medianoche: ” + horas);

// Obtenemos el modulo que sean los minutos
long minutosMili = milisegundos % (1000 * 60 * 60);
// Calculamos los minutos
minutos = minutosMili / (1000 * 60);
System.out.println(“Minutos medianoche: ” + minutos);

// Obtenemos el modulo de los minutos
long segundosMili = minutosMili % (1000 * 60);
// Calculamos los segundos
segundos = segundosMili / 1000;

System.out.println(“Segundos medianoche: ” + segundos);

// Presentamos los datos
System.out.println(“Tiempo para mediaNoche: ” + horas + “:”
+ minutos + “:” + segundos);

}
}