java.util.Timestamp.after() incorrecto al comparar milisegundos?

Question

Estoy sacando fechas de una base de datos Oracle. Se establecen en un campo java.util.Date y en realidad son instancias de java.sql.Timestamp (que es una subclase de Java.util.Date). Si comparo dos de estas marcas de tiempo de dos registros de bases de datos diferentes al llamar después de() en la primera fecha y compararla con la segunda, recibo la respuesta incorrecta cuando todas las partes de la fecha son las mismas, excepto por los milisegundos.

Todo lo siguiente debe dar lugar a "verdadero", sin embargo, el segundo conjunto de números no:

firstDate = 1/1/2000 12:00:20:00 
secondDate = 1/1/2000 12:00:10:00 
result = firstDate.after(secondDate); 
result is TRUE <-- EXPECTED RESULT 

firstDate = 1/1/2000 12:00:00:10 
secondDate = 1/1/2000 12:00:00:00 
result = firstDate.after(secondDate); 
result is FALSE <-- NOT EXPECTED, result should be TRUE 

Sé nanos se almacenan por separado de la instancia Fecha en la clase de marca de hora y estoy ansioso por ver si este es el problema.

Answer 1

Puede compararlos, pero solo comparando millis. Si bien es bastante feo, parece funcionar en todos los casos (independientemente de cuál sea java.sql.Timestamp o java.util.Date).

if(date1.getTime() > date2.getTime()) { 
    //... 
} 

Answer 2

Parece que el problema que tiene es que firstDate y secondDate están configurados en objetos Java.util.Date pero JavaDoc para java.sql.Timestamp menciona que es un compuesto de java.util.Date y un valor de nanosegundos por separado.

Es por esto que se devuelve falso cuando intenta comparar los dos. Si cambió firstDate y secondDate a los objetos Timestamp reales, deberían funcionar.

Answer 3

Sin el código real esto es una especulación, pero creo que uno de sus objetos es java.util.Date y el otro es java.sql.Timestamp realmente no se puede comparar ellos, como el campo millis en 'Marca de tiempo' se trunca a un segundo y el resto es almacenado en el campo nanos. Es realmente desafortunado que Timestamp es una subclase de Date. Esto definitivamente lleva a un problema que estás experimentando.

EDITAR.

Una posibilidad más, es que su controlador DB devuelve su propia subclase de Timestamp. Debido a que la clase no es definitiva, es muy posible que su implementación arruine la marca de tiempo compare, no es particularmente difícil de hacer.

Answer 4

La clave del problema aquí es cuando las marcas de tiempo se transfieren a los objetos Date. El método después de de Fecha se está utilizando en lugar del después del método en Timestamp. Cuando no se envía a la fecha, el método después de de Timestamp funcionará correctamente.

Supongo que necesito una lección ahora en covariant method parameters acerca de por qué el después del método en Timestamp no se llama en el siguiente código.

java.sql.Timestamp one = new java.sql.Timestamp(1266873627200L); 
    java.sql.Timestamp two = new java.sql.Timestamp(1266873627000L); 

    java.util.Date oneDate = (java.util.Date) one; 
    java.util.Date twoDate = (java.util.Date) two; 


    System.out.println("one: " + oneDate.getTime()); 
    System.out.println("two: " + twoDate.getTime()); 

    if (oneDate.after(twoDate)) { 
     System.out.println(oneDate.getTime() + " after " + twoDate.getTime()); 
    } else { 
     System.out.println(twoDate.getTime() + " after " + oneDate.getTime()); 
    } 

resultados

one: 1266873627200 
two: 1266873627000 
1266873627000 after 1266873627200