Obtenir l'horodatage pour le début de la journée

Je suis le stockage de date/heure dans une base de données à l'aide d'un timestamp unix.
Je veux puis obtenir toutes les instances d'un certain jour, alors j'ai donc besoin de calculer le timestamp pour le début de la journée, afin d'interroger la base de données.

J'ai fait une chose similaire en php en passant mktime les valeurs pour le jour/mois/année à partir d'un objet date, et du réglage de l'heure et de la minute à zéro. Il ne semble pas être des fonctions similaires pour cela en java/android (les fonctions pour obtenir les parties spécifiques de la date sont obsolètes)

Quelqu'un peut-il donner de conseils à ce sujet? Grâce

Edit:

Ok, donc j'ai réalisé cela peut fonctionner:

public static int startOfDay(Timestamp time) {
        Calendar cal = dateToCalendar(new Date(time.getTime()));
        cal.add(Calendar.HOUR_OF_DAY, -Calendar.HOUR_OF_DAY);
        cal.add(Calendar.MINUTE, -Calendar.MINUTE);
        cal.add(Calendar.SECOND, -Calendar.SECOND);
        Log.i("Time", cal.getTime().toString());        
        return (int) cal.getTimeInMillis()/1000;
}

Cependant quand j'ai couru ce seulement maintenant que j'ai obtenu:

Sat Dec 15 01:24:00 GMT 2012

Les secondes sont droit, mais les heures et les minutes sont mauvais??

source d'informationauteur Henry Ing-Simmons

android

35

Lorsque vous traitez avec le temps, vous devez toujours tenir compte des fuseaux horaires. Vous base de données horodatages doit toujours être stocké dans un fuseau horaire (par exemple, UTC). Votre calcul doit alors considérer que les utilisateurs peuvent être dans des fuseaux horaires différents et qu'ils peuvent changer les fuseaux horaires.

Si vous voulez calculer début de la journée dans le fuseau horaire de l'utilisateur a fixé dans son téléphone. Créer le Calendar exemple:
```
Calendar cal = Calendar.getInstance(); 
```
Pour obtenir l'instance pour un fuseau horaire spécifique d'utilisation:
```
//use UTC time zone
Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
```
Puis définissez le début de la journée:
```
cal.setTime(time); //compute start of the day for the timestamp
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
```

public static int startOfDay(Timestamp time) {
    Calendar cal = Calendar.getInstance();
    cal.setTimeInMillis(time.getTime());
    cal.set(Calendar.HOUR_OF_DAY, 0); //set hours to zero
    cal.set(Calendar.MINUTE, 0); //set minutes to zero
    cal.set(Calendar.SECOND, 0); //set seconds to zero
    Log.i("Time", cal.getTime().toString());        
    return (int) cal.getTimeInMillis()/1000;
}

1

tl;dr
```
ZoneId z = ZoneId.of( "America/Montreal" );
long secondsSinceEpoch = ZonedDateTime.now( z ).toLocalDate().asStartOfDay( z ).toEpochSecond() ;
```
Détails

Accepté Réponse par Tomik est correct, mais obsolète. Le gênants ancien héritage de date-heure classes ont été supplanté par le java.les classes de temps.

Que cette Réponse vous est conseillé, vous devez tenir compte de fuseau horaire lors de la prise en début de journée. Un fuseau horaire est crucial dans la détermination d'une date. Pour un moment donné, la date varie à travers le monde par zone. Par exemple, quelques minutes après minuit à Paris, la France est un nouveau jour, alors encore “hier” à Montréal, Québec.
```
ZoneId z = ZoneId.of( "America/Montreal" );
ZonedDateTime zdt = ZonedDateTime.now( z );
```
Arriver le premier moment de la journée, il faut aller à travers LocalDate. Le LocalDate classe représente une date uniquement de la valeur, sans le temps de la journée et sans fuseau horaire.
```
LocalDate today = zdt.toLocalDate();
ZonedDateTime zdtTodayStart = today.atStartOfDay( z );
```
Noter que nous laissons java.le temps de déterminer le début de la journée plutôt que d'assumer et de codage en dur 00:00:00. En raison de l'Heure d'été (DST) et d'autres anomalies, la journée peut commencer à un autre moment comme 01:00:00.

Apparemment, par unix timestamp vous dire un nombre de secondes depuis le premier instant de 1970 à UTC. Le ZonedDateTime classe a une méthode qui vous donnera le nombre. Remarque, cela peut signifier la perte de données comme le ZonedDateTime peut avoir une fraction de seconde avec une résolution de nanosecondes.
```
long secondsSinceEpoch = zdtTodayStart.toEpochSecond();
```
Sur java.temps

La java.le temps cadre est intégré dans Java 8 et les versions ultérieures. Ces classes permettent d'éviter la pénible vieille date-heure classes telles que java.util.Date.Calendar& java.text.SimpleDateFormat.

La Joda-Time projet, maintenant dans le mode de maintenanceconseille la migration vers java.temps.

Pour en savoir plus, consultez les Oracle Tutoriel. Et de recherche de Débordement de Pile pour de nombreux exemples et des explications.

Une grande partie de la java.fonction temps est de retour, porté à Java 6 & 7 dans ThreeTen-Backport et plus adapté à Android dans ThreeTenABP (voir Comment l'utiliser...).

La ThreeTen-Extra projet s'étend java.temps avec d'autres classes. Ce projet est un terrain d'essai pour de possibles futurs ajouts à java.temps. Vous pouvez trouver quelques classes utiles ici comme IntervalYearWeekYearQuarteret plus encore.

Vous devez vous connecter pour publier un commentaire.

tl;dr

Détails

Sur java.temps