java.util.Timestamp.after() incorrect lors de la comparaison des millisecondes?

Question

Je tire des dates d'une base de données Oracle. Ils sont définis sur un champ java.util.Date et sont en réalité des instances java.sql.Timestamp (qui est une sous-classe de Java.util.Date). Si je compare deux timestamps de deux enregistrements de base de données différents en appelant after() à la première date et en la comparant à la seconde, j'obtiens la mauvaise réponse lorsque toutes les parties de la date sont identiques sauf les millisecondes.

Tous les éléments suivants doivent se traduire par « true », mais la deuxième série de chiffres ne:

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 

Je sais nanos sont stockés séparément à partir de la date dans la classe Horodatage et je suis curieux de savoir si C'est le problème.

Answer 1

Vous pouvez les comparer, mais seulement en comparant millis. Bien que ce soit assez laid, il semble fonctionner dans tous les cas (indépendamment de ce qui est java.sql.Timestamp ou java.util.Date).

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

Answer 2

Il semble que le problème que vous rencontrez est que firstDate et secondDate sont définis sur des objets Java.util.Date, mais le JavaDoc pour java.sql.Timestamp mentionne qu'il s'agit d'un composite de java.util.Date et d'une valeur de nanosecondes séparée.

C'est pourquoi il renvoie false lorsque vous essayez de comparer les deux. Si vous avez modifié firstDate et secondDate sur des objets Timestamp réels, ils devraient fonctionner.

Answer 3

Sans le code réel ceci est une spéculation, mais je pense que l'un de vos objets est java.util.Date et l'autre est java.sql.Timestamp vous ne pouvez pas vraiment les comparer, comme le champ millis dans « Timestamp » est tronquée à une seconde et le reste est stocké dans le champ nanos. Il est vraiment malheureux que Timestamp est une sous-classe de Date. Cela conduit définitivement à un problème que vous rencontrez.

EDIT.

Une autre possibilité est que votre pilote de base de données renvoie sa propre sous-classe Timestamp. Parce que la classe n'est pas finale, il est tout à fait possible que leur mise en œuvre foiré compare Timestamp, pas que ce soit particulièrement difficile à faire.

Answer 4

La clé du problème ici est lorsque les horodatages sont convertis en objets Date. La méthode après de Date est utilisée à la place de la méthode après dans Horodatage. Lorsque non cast à Date, la méthode après de Timestamp fonctionnera correctement.

Je suppose que j'ai besoin d'une leçon maintenant sur covariant method parameters pour savoir pourquoi la méthode après dans Timestamp n'est pas appelée dans le code suivant.

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()); 
    } 

résultats

one: 1266873627200 
two: 1266873627000 
1266873627000 after 1266873627200