Comment faire pour déterminer si 48 heures a passé à partir d'un moment précis?

Je cherche à vérifier et voir si les 48 heures a collé à partir d'un moment précis?
Je suis à l'aide de cette date format de l'heure (aaaa/MM/jj hh:mm:ss) Est-il une fonction java pour cela?

Avez-vous essayé quelque chose encore? Les bibliothèques comme Joda-Time? Le calcul de millisecondes écoulées entre la date de réservation?
Convertir les deux chaines de temps pour les horodatages et vérifier qu'elles sont plus que 48 * 3600 * 1000 millisecondes d'intervalle.
double possible de Comment calculer la différence de temps en java?
double possible de le Calcul de la Différence Entre Java Deux Occurrences de Date

OriginalL'auteur user1157157 | 2012-01-18

java time

7

Sûr. ~~je conseil vivement de vous procurer Joda DateTime~~. @Basile Bourque mettre dans un commentaire, Joda est maintenant en mode de maintenance et depuis Java 8, vous devez utiliser le java.méthodes d'.

Conseillé de code qui n'est pas dépendants de la bibliothèque et est de plus en plus clair sur ce qu'il fait:
```
//How to use Java 8's time utils to calculate hours between two dates
LocalDateTime dateTimeA = LocalDateTime.of(2017, 9, 28, 12, 50, 55, 999);
LocalDateTime dateTimeB = LocalDateTime.of(2017, 9, 30, 12, 50, 59, 851);
long hours = ChronoUnit.HOURS.between(dateTimeA, dateTimeB);
System.out.println(hours);
```
Original suggéré de code (pas aussi dépendants de la bibliothèque):
```
//pseudo-code
DateTime a = new DateTime("old time");
DateTime b = new DateTime(" now    ");

//get hours
double hours = (a.getMillis() - b.getMillis()) / 1000 / 60 / 60;
if(hours>48) ...
```
Je suis d'accord à l'aide de Joda DateTime est le mieux; sinon, vous pouvez utiliser le Calendrier natif à la place (mais Joda DateTime est plus simple).
Pour info, le Joda-Time projet est maintenant en mode de maintenance, avec l'équipe conseiller de la migration à la java.les classes de temps.
thks pour la mise à jour. J'ai édité réponse en conséquence.

OriginalL'auteur Frankie

J'ai été en mesure d'accomplir cela en utilisant un JodaTime Bibliothèque dans mon projet. Je suis sorti avec ce code.

String datetime1 = "2012/08/24 05:22:34";
String datetime2 = "2012/08/24 05:23:28";

DateTimeFormatter format = DateTimeFormat.forPattern("yyyy/MM/dd HH:mm:ss");
DateTime time1 = format.parseDateTime(datetime1);
DateTime time2 = format.parseDateTime(datetime2);
Minutes Interval = Minutes.minutesBetween(time1, time2);
Minutes minInterval = Minutes.minutes(20);

if(Interval.isGreaterThan(minInterval)){
  return true;
}
else{
  return false;
}

Il s'agira de vérifier si l'Intervalle de Temps entre datetime1 et datetime2 est GreaterThan 20 Minutes. Modifier la propriété de Jours. Il sera plus facile pour vous maintenant. Cette retournera false.

OriginalL'auteur John Paul Manoza

Vous pouvez ajouter de 48 heures à une date donnée, et puis, si le résultat est plus tôt que votre date de départ, vous savez que vous êtes passé de 48 heures.

Date dateInQuestion = getDateInQuestion();

Calendar cal = Calendar.getInstance();
cal.setTime(dateInQuestion);
cal.add(Calendar.HOUR, 48);
Date futureDate = cal.getTime();

if (dateInQuestion.after(futureDate)) {
  //Then more than 48 hours have passed since the date in question
}

OriginalL'auteur Cuga

Date twoDaysAgo = new Date(System.currentTimeMillis() - 1000 * 60 * 60 * 24 * 2);
Date parsedDate = new SimpleDateFormat("y/M/d h:m:s").parse(myDateString);
boolean hasTimePasssed = parsedDate.before(twoDaysAgo);

OriginalL'auteur cheeken

Si vous n'avez pas besoin de gérer des cas particuliers, vous pouvez utiliser le .avant de() la fonction et de faire un jour l'objet à représenter il y a 48 heures:

long millisIn48Hours = 1000 * 60 * 60 * 48;
Date timestamp = new Date(0);//use the date you have, parse it using SimpleDateFormat if needed.
Date hours48ago = new Date(new Date().getTime() - millisIn48Hours);

if (timestamp.before(hours48ago)) {
    //48 hours has passed.
}

EDIT: je ne voudrais pas ajouter une bibliothèque à la dépendance pour quelque chose de si simple, mais si vous allez utiliser JodaTime, je voudrais utiliser leurs méthodes pratiques plutôt que de calculer le décalage dans le temps comme dans l'autre réponse:

DateTime original = new DateTime("your original date object");
DateTime now = new DateTime();
DateTime minus48 = now.minusHours(48);

if (original.isBefore(minus48)) {
    //48 hours has elapsed. 
}

OriginalL'auteur Casey

Vous pouvez utiliser les éléments suivants:

 DateTime specificDate = new DateTime(" some specific date");
 DateTime now = new DateTime();

 if(TimeUnit.MILLISECONDS.toHours(now.getMillis() - specificDate.getMillis()) > 48) {
    //Do something
  }

J'espère que cela peut vous aider.

OriginalL'auteur ziniestro

0

En plus de Joda DateTime

Si vous voulez vérifier si une date est entre autre laps de temps, dire, c'est date1 4h entre date2, joda a différentes classes juste pour ces scénarios, vous pouvez utiliser:
```
Hours h = Hours.hoursBetween(date1, date2);
Days s = Days.daysBetween(date1, date2);
Months m = Months.monthsBetween(date1,date2);
```
http://joda-time.sourceforge.net/apidocs/org/joda/time/base/BaseSingleFieldPeriod.html

Pour info, le Joda-Time projet est maintenant en mode de maintenance. L'équipe conseille les migrations à la java.les classes de temps.

OriginalL'auteur mel3kings
0

La Joda-Time projet est maintenant en mode de maintenance. L'équipe conseille les migrations à la java.les classes de temps.

java.temps

La méthode moderne utilise le java.les classes de temps.

Analyse de votre entrée de chaîne de format yyyy/MM/dd hh:mm:ss. C'est presque dans la norme ISO 8601. Ajuster à respecter.
```
String input = "2017/01/23 12:34:56".replace( "/" , "-" ).replace( " " , "T" ).concat( "Z" ) ;
```
Si possible, utilisez des formats standard plutôt que d'inventer votre propre lors d'un échange de date-heure de valeurs sous forme de texte. La java.les classes de temps utiliser les formats standard par défaut lors de l'analyse et de génération de chaînes.

Analyser comme une valeur en UTC.
```
Instant instant = Instant.parse( input ) ;
```
Obtenir l'heure actuelle.
```
Instant now = Instant.now() ;
```
Comparer à un laps de temps de 48 heures.
```
Duration d = Duration.ofHours( 48 ) ;
if ( instant.plus( d ).isBefore( now ) ) { … }
```
OriginalL'auteur Basil Bourque

Vous devez vous connecter pour publier un commentaire.

java.temps