segundos - Restablecer la parte de tiempo de una marca de tiempo en Java

timer java 8

Question

En Java, con una marca de tiempo, ¿cómo restablecer la parte de tiempo solo a 00:00:00 para que la marca de tiempo represente la medianoche de ese día en particular?

En T-SQL, esta consulta hará lo mismo, pero no sé cómo hacer esto en Java.

SELECT CAST( FLOOR( CAST(GETDATE() AS FLOAT ) ) AS DATETIME) AS ''DateTimeAtMidnight'';

Answer 1

Como no hago mucha manipulación de DateTime, esta podría no ser la mejor manera de hacerlo. Generaría un Calendario y usaría la Fecha como fuente. Luego configure horas, minutos y segundos en 0 y conviértelos nuevamente a la fecha. Aunque sería bueno ver una mejor manera.

Answer 2

Puede ir a Fecha-> Calendario-> configurar-> Fecha:

Date date = new Date(); // timestamp now
Calendar cal = Calendar.getInstance(); // get calendar instance
cal.setTime(date); // set cal to date
cal.set(Calendar.HOUR_OF_DAY, 0); // set hour to midnight
cal.set(Calendar.MINUTE, 0); // set minute in hour
cal.set(Calendar.SECOND, 0); // set second in minute
cal.set(Calendar.MILLISECOND, 0); // set millis in second
Date zeroedDate = cal.getTime(); // actually computes the new Date

Me encantan las fechas de Java

Tenga en cuenta que si usa java.sql.Timestamps reales, tienen un campo nanos adicional. El calendario, por supuesto, no sabe nada de los nanos, por lo que lo ignorará a ciegas y lo abandonará efectivamente al crear el zeroedDate al final, que luego podría usar para crear un nuevo objeto Timetamp.

También debería tener en cuenta que Calendar no es seguro para subprocesos, por lo tanto, no piense que puede hacer que una instancia de una sola cal estática se invoque desde varios subprocesos para evitar la creación de nuevas instancias de Calendar.

Answer 3

Suponiendo que su "marca de tiempo" es un java.util.Date, que se representa como el número de milisegundos desde el comienzo de la época (1 de enero de 1970), puede realizar la siguiente aritmética:

public static Date stripTimePortion(Date timestamp) {
long msInDay = 1000 * 60 * 60 * 24; // Number of milliseconds in a day
long msPortion = timestamp.getTime() % msInDay;
return new Date(timestamp.getTime() - msPortion);
}

Answer 4

Usar Calendar.set () sería ciertamente una solución "por libro", pero también podría usar java.sql.Date:

java.util.Date originalDate = new java.util.Date();
java.sql.Date wantedDate = new java.sql.Date(originalDate.getTime());

Eso haría exactamente lo que quieras desde:

Para cumplir con la definición de SQL DATE, los valores de milisegundos envueltos por una instancia de java.sql.Date deben ''normalizarse'' al establecer las horas, minutos, segundos y milisegundos en cero en la zona horaria particular a la que está asociada la instancia. .

Como java.sql.Date extiende java.util.Date, puede usarlo libremente como tal. Tenga en cuenta que wantedDate.getTime () recuperará la marca de tiempo original, es por eso que no desea crear otro java.util.Date desde java.sql.Date.

Answer 5

Yo prefiero esta solución:

GregorianCalendar now = new GregorianCalendar();
GregorianCalendar calendar = new GregorianCalendar(
now.get(GregorianCalendar.YEAR), now.get(GregorianCalendar.MONTH),
now.get(GregorianCalendar.DAY_OF_MONTH));

Answer 6

Si está utilizando commons lang puede llamar a DateUtils.truncate . Aquí está la documentación de javadoc .

Hace lo mismo @ dijo Alex Miller que hacer.

Answer 7

Hacer esto

import org.apache.commons.lang.time.DateUtils;
Date myDate = new Date();
System.out.println(myDate);
System.out.println(DateUtils.truncate(myDate, Calendar.DATE));

y el resultado es

Wed Mar 19 14:16:47 PDT 2014
Mié mar 19 00:00:00 PDT 2014

Answer 8

Encuentre a continuación una solución que emplea Joda Time y admite zonas horarias. Por lo tanto, obtendrá la fecha y la hora actuales (en fecha actual y hora actual) o alguna fecha y hora a las que informe (en Hora informada e Hora informedTime ) en la zona horaria configurada actualmente en la JVM.

El código a continuación también informa si la fecha / hora informada está en el futuro (variable schedulable ).

Tenga en cuenta que Joda Time no admite segundos intercalares . Por lo tanto, puede estar a unos 26 o 27 segundos del valor verdadero. Esto probablemente solo se resuelva en los próximos 50 años, cuando el error acumulado será más cercano a 1 minuto y las personas comenzarán a preocuparse por ello.

Ver también: https://en.wikipedia.org/wiki/Leap_second

/**
* This class splits the current date/time (now!) and an informed date/time into their components:
* <lu>
* <li>schedulable: if the informed date/time is in the present (now!) or in future.</li>
* <li>informedDate: the date (only) part of the informed date/time</li>
* <li>informedTime: the time (only) part of the informed date/time</li>
* <li>currentDate: the date (only) part of the current date/time (now!)</li>
* <li>currentTime: the time (only) part of the current date/time (now!)</li>
* </lu>
*/
public class ScheduleDateTime {
public final boolean schedulable;
public final long millis;
public final java.util.Date informedDate;
public final java.util.Date informedTime;
public final java.util.Date currentDate;
public final java.util.Date currentTime;
public ScheduleDateTime(long millis) {
final long now = System.currentTimeMillis();
this.schedulable = (millis > -1L) && (millis >= now);
final TimeZoneUtils tz = new TimeZoneUtils();
final java.util.Date dmillis = new java.util.Date( (millis > -1L) ? millis : now );
final java.time.ZonedDateTime zdtmillis = java.time.ZonedDateTime.ofInstant(dmillis.toInstant(), java.time.ZoneId.systemDefault());
final java.util.Date zdmillis = java.util.Date.from(tz.tzdate(zdtmillis));
final java.util.Date ztmillis = new java.util.Date(tz.tztime(zdtmillis));
final java.util.Date dnow = new java.util.Date(now);
final java.time.ZonedDateTime zdtnow = java.time.ZonedDateTime.ofInstant(dnow.toInstant(), java.time.ZoneId.systemDefault());
final java.util.Date zdnow = java.util.Date.from(tz.tzdate(zdtnow));
final java.util.Date ztnow = new java.util.Date(tz.tztime(zdtnow));
this.millis = millis;
this.informedDate = zdmillis;
this.informedTime = ztmillis;
this.currentDate = zdnow;
this.currentTime = ztnow;
}
}
public class TimeZoneUtils {
public java.time.Instant tzdate() {
final java.time.ZonedDateTime zdtime = java.time.ZonedDateTime.now();
return tzdate(zdtime);
}
public java.time.Instant tzdate(java.time.ZonedDateTime zdtime) {
final java.time.ZonedDateTime zddate = zdtime.truncatedTo(java.time.temporal.ChronoUnit.DAYS);
final java.time.Instant instant = zddate.toInstant();
return instant;
}
public long tztime() {
final java.time.ZonedDateTime zdtime = java.time.ZonedDateTime.now();
return tztime(zdtime);
}
public long tztime(java.time.ZonedDateTime zdtime) {
final java.time.ZonedDateTime zddate = zdtime.truncatedTo(java.time.temporal.ChronoUnit.DAYS);
final long millis = zddate.until(zdtime, java.time.temporal.ChronoUnit.MILLIS);
return millis;
}
}

Answer 9

Aquí hay una función simple con un ejemplo principal:

import java.util.Calendar;
import java.util.Date;
public class Util {
/**
* Returns an imprecise date/timestamp.
* @param date
* @return the timestamp with zeroized seconds/milliseconds
*/
public static Date getImpreciseDate(Date date) {
Calendar cal = Calendar.getInstance(); // get calendar instance
cal.setTime(date);// set cal to date
cal.set(Calendar.SECOND, 0); // zeroize seconds
cal.set(Calendar.MILLISECOND, 0); // zeroize milliseconds
return cal.getTime();
}
public static void main(String[] args){
Date now = new Date();
now.setTime(System.currentTimeMillis()); // set time to now
System.out.println("Precise date: " + Util.getImpreciseDate(now));
System.out.println("Imprecise date: " + Util.getImpreciseDate(now));
}
}