Fusion de java.util.date avec java.sql.Le temps

J'ai une vaste DATE de conversion en TEMPS de classe, mais je suis tombé sur un scénario que je ne peut pas résoudre:

J'ai un java.util.date: Mar Mai 10 00:00:00 BST 2011
J'ai un java.sql.durée: 03:58:44

J'ai besoin de créer un java.util.date: Mardi 10 Mai à 03:58:44 BST 2011

La seule approche que j'ai trouvé est:

public static Date getDate(Date date, Time time) {
    Calendar calendar=Calendar.getInstance();
    calendar.set(date.getYear(), date.getMonth(), date.getDay(), time.getHours(), time.getMinutes(), time.getSeconds());
    return calendar.getTime();
}

Totalement obsolète code, et ne fonctionne pas:
java.lang.IllegalArgumentException à java.sql.Temps.getYear(Source Inconnue)

Des idées?

Si vous avez obtenu cette exception que le code, alors vous avez réellement passé dans un Time exemple sur le premier paramètre!
joda-time est toujours la meilleure approche pour travailler avec des dates en java joda-time.sourceforge.net
<rant>Sur une partie liée remarque: lors de la java.util.Date API est très mal construit et devrait depuis longtemps avoir été remplacer par un sain d'esprit (comme Joda Time), la java.sql.Date et java.sql.Time "extension" est encore pire: Ils ne pas suivre le principe de substitution de Liskov et pour empirer les choses java.sql.Date même a le même nom que sa classe de base.</rant>
Je suis d'accord, j'ai dû faire une optimisation de la conversion de la classe qui a tout ce dont j'ai besoin et qui fait SENS pour moi... java.util.date est une douleur... mais pour l'instant j'ai juste besoin d'une solution simple à ce scénario.

OriginalL'auteur marcolopes | 2011-05-10

10

java.sql.Le temps est juste un wrapper sur le java.util.Date. Vous pouvez l'utiliser comme si vous ajoutez deux java.util.Les objets Date.

Par exemple, d'ajuster le Calendrier de java.sql.Temps:
```
calendar.setTime(time);
```
Maintenant extraire les heures/minutes/secondes les champs, c'est à dire:
```
calendar.get(Calendar.HOUR);
```
Ensuite, fixer le Calendrier de java.util.Objet Date et ajouter ces trois champs de son temps, c'est à dire:
```
calendar.add(Calendar.HOUR, hour);
```
Et obtenir la Date de retour:
```
calendar.getTime();
```
Juste une remarque: on doit utiliser HOUR_OF_DAY de respecter le format de 24 heures.
Après de nombreux tests, C'est la seule solution correcte!

OriginalL'auteur acalypso
4

Plus simple serait d'ajouter simplement la milli secondes ensemble pour créer une nouvelle date, ala
```
public static Date getDate(Date date, Time time) {
    return new Date(date.getTime() + time.getTime())
}
```
Fonctionne, Mais j'ai une heure de moins... Mar Mai 10 00:00:00 BST 2011 & 03:58:44 = Mar 10 Mai 02:58:44 BST 2011

OriginalL'auteur vickirk
4

vickirk la solution n'était pas si mal, mais a fuseau horaire questions, ce qui résulte en une heure de moins que vous avez observé.

Je suppose, BST signifie British Summer Time, qui est GMT +0100. Maintenant, java.util.De la Date et de ses descendants à l'interne le travail avec le nombre de millisecondes écoulées depuis minuit Jan 01, 1970 GMT. Le fuseau horaire n'est pas pris en compte jusqu'à ce que vous stringfy la date et l'heure avec toString(). Et ils utilisent votre fuseau horaire local pour ce qui est de la STB, apparemment. Cela signifie que, ce qui est réellement stocké dans ces objets, est

java.util.date: Lun Mai 09 23:00:00 GMT 2011

java.sql.temps: 02:58:44 GMT

Lorsque vous ajoutez les valeurs internes (qui sont récupérés par getTime()) comme vickirk suggéré que vous obtenir une date qui contient

Mar 10 Mai 01:58:44 GMT 2011, ce qui donne

Mar 10 Mai 02:58:44 BST 2011 sur stringification.

Donc l'explication de la une heure de moins, c'est que le décalage horaire s'applique à deux reprises, lorsque vous stringified les valeurs séparément, alors qu'il s'applique qu'une seule fois après l'addition, parce que vous stringfy qu'une seule fois maintenant. Ou, d'un autre point de vue, l'ajout de la valeur interne de la point dans le temps 03:58:44 BST est équivalent à l'ajout d'un laps de temps de 2h 58m 44s.

De manière à obtenir un temps de span de 3h 58m 44s codé en java.sql.Temps, vous avez à faire pour le décalage de fuseau horaire manuellement. Vous ne faites que par l'analyse de la chaîne de temps "00:00:00" avec java.sql.Le temps, ce qui entraînera une valeur interne de -3600000 qui est équivalent au 31 Décembre 1969 23:00:00 GMT, c'est à dire une heure avant l'époque. C'est le négatif du décalage horaire.
```
public static Date mergeDate(Date date, Time time) {
    long tzoffset = -(Time.valueOf("00:00:00").getTime());
    return new Date(date.getTime() + time.getTime() + tzoffset);
}
```
Bien sûr, tout cela est un gros hack, qui est nécessaire parce que vous insistez sur l'interprétation de la valeur d'un laps de temps, alors que c'est vraiment un point dans le temps.

Je ne peux pas penser à une meilleure façon de "fusionner" une DATE (sans le "temps" de l'information) avec un Sql Temps (pas de "date" de l'information). J'ai besoin de comparer des dates, et l'une des sources est une table SQL qui me donne une DATE et une HEURE que je dois mettre ensemble.

OriginalL'auteur T-Bull
2

Au lieu de cela, vous pouvez utiliser cette.
```
   public static Date getDate(Date date, Time time) {
        Calendar calendar=Calendar.getInstance();
        calendar.setTimeZone(TimeZone.getTimeZone("UTC"));
        calendar.setTime(date);
        calendar.add(Calendar.MILLISECOND, (int) time.getTime());
        return calendar.getTime();
    }
```
non... retourne le: Jeu Jan 01 06:58:52 GMT 1970...
Désolé, il fonctionne, Mais j'ai une heure de moins. Mar Mai 10 00:00:00 BST 2011 & 03:58:44 = Mar 10 Mai 02:58:44 BST 2011
C'est parce que vous avez besoin de régler le fuseau horaire correctement. utilisation setTimezone() la méthode du calendrier.
Je suis confus... java.util.date de ne pas tenir le fuseau horaire?
Voir la modification de code.

OriginalL'auteur Manoj
1

Pouvez-vous faire
```
java.util.Date newDate = new java.util.Date(sqlDate.getTime());
```
C'était mon premier essai... il retourne: Thu Jan 01 03:59:26 GMT 1970 :-\ Donc, le TEMPS est ok, mais réinitialise tous les autres champs.
java.sql.Temps est une java.util.Date 😉

OriginalL'auteur John Vint

essayez ces

 public static Date getDate(Date date, Time time) {
            Calendar calendar=Calendar.getInstance();
            calendar.setTime(date);
            Calendar calendar1=Calendar.getInstance();
            calendar1.setTime(time);
            calendar.set(Calendar.MINUTE, calendar1.get(Calendar.MINUTE));
            calendar.set(Calendar.SECOND, calendar1.get(Calendar.SECOND));
            calendar.set(Calendar.HOUR_OF_DAY, calendar1.get(Calendar.HOUR_OF_DAY));
            return calendar.getTime();
        }

OriginalL'auteur sunil

Vous devez vous connecter pour publier un commentaire.