Vérifier si un temps donné est compris entre deux fois quelle que soit la date
J'ai des délais:
Temps de chaîne1 = 01:00:00
Temps de chaîne2 = 05:00:00
Je veux vérifier si time1 et time2 les deux se situent entre 20:11:13 and 14:49:00.
En fait, 01:00:00 est supérieur à 20:11:13 et inférieur à 14:49:00, car 20:11:13 est toujours inférieur à 14:49:00. Ceci est donné prérequis.
Donc, ce que je veux, c'est 20:11:13 < 01:00:00 < 14:49:00.
J'ai donc besoin de quelque chose comme ça:
public void getTimeSpans()
{
boolean firstTime = false, secondTime = false;
if(time1 > "20:11:13" && time1 < "14:49:00")
{
firstTime = true;
}
if(time2 > "20:11:13" && time2 < "14:49:00")
{
secondTime = true;
}
}
Je sais que ce code ne donne pas un résultat correct, car je compare les objets chaîne.
Comment faire cela, car ce sont les délais, mais pas les chaînes à comparer?
Vous pouvez utiliser la classe Calendar pour vérifier.
Par exemple:
try {
String string1 = "20:11:13";
Date time1 = new SimpleDateFormat("HH:mm:ss").parse(string1);
Calendar calendar1 = Calendar.getInstance();
calendar1.setTime(time1);
String string2 = "14:49:00";
Date time2 = new SimpleDateFormat("HH:mm:ss").parse(string2);
Calendar calendar2 = Calendar.getInstance();
calendar2.setTime(time2);
calendar2.add(Calendar.DATE, 1);
String someRandomTime = "01:00:00";
Date d = new SimpleDateFormat("HH:mm:ss").parse(someRandomTime);
Calendar calendar3 = Calendar.getInstance();
calendar3.setTime(d);
calendar3.add(Calendar.DATE, 1);
Date x = calendar3.getTime();
if (x.after(calendar1.getTime()) && x.before(calendar2.getTime())) {
//checkes whether the current time is between 14:49:00 and 20:11:13.
System.out.println(true);
}
} catch (ParseException e) {
e.printStackTrace();
}
La réponse donnée par @kocko ne fonctionne que le même jour.
Si l'heure de début "23:00:00" et fin "02:00:00" [jour suivant] et que l'heure actuelle est "01:30:00" alors le résultat sera faux ...
J'ai modifié la réponse de @ kocko pour fonctionner parfaitement
public static boolean isTimeBetweenTwoTime(String initialTime, String finalTime,
String currentTime) throws ParseException {
String reg = "^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$";
if (initialTime.matches(reg) && finalTime.matches(reg) &&
currentTime.matches(reg))
{
boolean valid = false;
//Start Time
//all times are from Java.util.Date
Date inTime = new SimpleDateFormat("HH:mm:ss").parse(initialTime);
Calendar calendar1 = Calendar.getInstance();
calendar1.setTime(inTime);
//Current Time
Date checkTime = new SimpleDateFormat("HH:mm:ss").parse(currentTime);
Calendar calendar3 = Calendar.getInstance();
calendar3.setTime(checkTime);
//End Time
Date finTime = new SimpleDateFormat("HH:mm:ss").parse(finalTime);
Calendar calendar2 = Calendar.getInstance();
calendar2.setTime(finTime);
if (finalTime.compareTo(initialTime) < 0)
{
calendar2.add(Calendar.DATE, 1);
calendar3.add(Calendar.DATE, 1);
}
Java.util.Date actualTime = calendar3.getTime();
if ((actualTime.after(calendar1.getTime()) ||
actualTime.compareTo(calendar1.getTime()) == 0) &&
actualTime.before(calendar2.getTime()))
{
valid = true;
return valid;
} else {
throw new IllegalArgumentException("Not a valid time, expecting
HH:MM:SS format");
}
}
}
Sortie
"07:00:00" - "17:30:00" - "15:30:00" [current] - true
"17:00:00" - "21:30:00" - "16:30:00" [current] - false
"23:00:00" - "04:00:00" - "02:00:00" [current] - true
"00:30:00" - "06:00:00" - "06:00:00" [current] - false
(J'ai inclus la valeur limite inférieure à [valeur limite supérieure-1])
tl; dr
20:11:13 <01:00:00 <14:49:00
LocalTime target = LocalTime.parse( "01:00:00" ) ;
Boolean targetInZone = (
target.isAfter( LocalTime.parse( "20:11:13" ) )
&&
target.isBefore( LocalTime.parse( "14:49:00" ) )
) ;
Java.time.LocalTime
Les classes Java.time incluent LocalTime pour représenter une heure uniquement sans date et sans fuseau horaire.
Donc, ce que je veux, c’est, 20:11:13 <01:00:00 <14:49:00.
Nous définissons d’abord les limites. Vos chaînes d’entrée sont conformes aux formats standard ISO 8601 . Les classes Java.time utilisent les formats ISO 8601 par défaut. Il n'est donc pas nécessaire de spécifier un modèle de formatage.
LocalTime start = LocalTime.parse( "20:11:13" );
LocalTime stop = LocalTime.parse( "14:49:00" );
Et définissons notre scénario de test, le 01:00:00 cible.
LocalTime target = LocalTime.parse( "01:00:00" );
Nous sommes maintenant prêts à comparer ces objets LocalTime. Nous voulons voir si la cible est après l'heure la plus tardive, mais avant l'heure la plus proche. Dans ce cas, cela signifie qu’il est au milieu de la nuit, entre environ 8 heures PM et 3 heures le lendemain matin.
Boolean isTargetAfterStartAndBeforeStop = ( target.isAfter( start ) && target.isBefore( stop ) ) ;
Ce test peut être plus simplement déclaré comme suit: «pas entre 3 heures et 20 heures». Nous pourrions ensuite généraliser à n'importe quelle paire d'objets LocalTime où nous testons entre si le début vient avant l'arrêt avec une horloge de 24 heures et pas entre si le début vient après l'arrêt (comme dans le cas précédent). cas de cette Question).
De plus, les périodes de temps sont généralement traitées avec l’approche Half-Open où le début est inclusif tandis que la fin est exclusif. Ainsi, une comparaison "entre", à proprement parler, serait "si la cible est égale ou plus tard que le début ET la cible est avant l'arrêt", ou plus simplement, "est la cible pas avant le début ET avant l'arrêt".
Boolean isBetweenStartAndStopStrictlySpeaking =
( ( ! target.isBefore( start ) && target.isBefore( stop ) ) ;
Si le début est après l'arrêt, dans un délai de 24 heures, supposons que nous voulons la logique suggérée dans la Question (se situe après 8 PM mais avant 3 heures).
if( start.isAfter( stop ) ) {
return ! isBetweenStartAndStopStrictlySpeaking ;
} else {
return isBetweenStartAndStopStrictlySpeaking ;
}
À propos de Java.time
Le cadre Java.time est intégré à Java 8 et versions ultérieures. Ces classes supplantent les anciennes classes gênantes héritées _ date-heure telles que Java.util.Date , Calendar _, & SimpleDateFormat .
Le projet Joda-Time , désormais en mode { mode maintenance }, conseille la migration vers les classes Java.time .
Pour en savoir plus, consultez le Oracle Tutorial . Et recherchez Stack Overflow pour de nombreux exemples et explications. La spécification est JSR 310 .
Vous pouvez échanger des objets Java.time directement avec votre base de données. Utilisez un pilote JDBC compatible avec JDBC 4.2 ou une version ultérieure. Pas besoin de chaînes, pas besoin de Java.sql.* classes.
Où obtenir les classes Java.time?
- Java SE 8 , Java SE 9 , Java SE 10 , et versions ultérieures
- Intégré.
- Une partie de l'API Java standard avec une implémentation fournie.
- Java 9 ajoute quelques fonctionnalités et corrections mineures.
- Java SE 6 et Java SE 7
- Une grande partie de la fonctionnalité Java.time est rétroportée vers Java 6 et 7 dans ThreeTen-Backport .
- Android
- Les versions ultérieures des bundles Android implémentent les classes Java.time.
- Pour les anciens Android (<26), le projet ThreeTenABP s’adapte ThreeTen-Backport (mentionné ci-dessus). Voir Comment utiliser ThreeTenABP… .
Le projet ThreeTen-Extra étend Java.time avec des classes supplémentaires. Ce projet est un terrain d’essai pour d’éventuels ajouts à Java.time. Vous pouvez y trouver des classes utiles telles que Interval _, YearWeek , YearQuarter _ et plus _.
Code modifié par @Surendra Jnawali. Il échoue
Si l'heure actuelle est 23:40:00 c'est-à-dire supérieure à l'heure de début et inférieure à 23:59:59.
Tout le mérite revient au vrai propriétaire
Voilà comment cela devrait être: Cela fonctionne parfaitement
public static boolean isTimeBetweenTwoTime(String argStartTime,
String argEndTime, String argCurrentTime) throws ParseException {
String reg = "^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$";
//
if (argStartTime.matches(reg) && argEndTime.matches(reg)
&& argCurrentTime.matches(reg)) {
boolean valid = false;
// Start Time
Java.util.Date startTime = new SimpleDateFormat("HH:mm:ss")
.parse(argStartTime);
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(startTime);
// Current Time
Java.util.Date currentTime = new SimpleDateFormat("HH:mm:ss")
.parse(argCurrentTime);
Calendar currentCalendar = Calendar.getInstance();
currentCalendar.setTime(currentTime);
// End Time
Java.util.Date endTime = new SimpleDateFormat("HH:mm:ss")
.parse(argEndTime);
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(endTime);
//
if (currentTime.compareTo(endTime) < 0) {
currentCalendar.add(Calendar.DATE, 1);
currentTime = currentCalendar.getTime();
}
if (startTime.compareTo(endTime) < 0) {
startCalendar.add(Calendar.DATE, 1);
startTime = startCalendar.getTime();
}
//
if (currentTime.before(startTime)) {
System.out.println(" Time is Lesser ");
valid = false;
} else {
if (currentTime.after(endTime)) {
endCalendar.add(Calendar.DATE, 1);
endTime = endCalendar.getTime();
}
System.out.println("Comparing , Start Time /n " + startTime);
System.out.println("Comparing , End Time /n " + endTime);
System.out
.println("Comparing , Current Time /n " + currentTime);
if (currentTime.before(endTime)) {
System.out.println("RESULT, Time lies b/w");
valid = true;
} else {
valid = false;
System.out.println("RESULT, Time does not lies b/w");
}
}
return valid;
} else {
throw new IllegalArgumentException(
"Not a valid time, expecting HH:MM:SS format");
}
}
R&EACUTE;SULTAT
Comparing , Start Time /n Thu Jan 01 23:00:00 IST 1970
Comparing , End Time /n Fri Jan 02 02:00:00 IST 1970
Comparing , Current Time /n Fri Jan 02 01:50:00 IST 1970
RESULT, Time lies b/w
Calendar now = Calendar.getInstance();
int hour = now.get(Calendar.HOUR_OF_DAY); // Get hour in 24 hour format
int minute = now.get(Calendar.MINUTE);
Date date = parseDate(hour + ":" + minute);
Date dateCompareOne = parseDate("08:00");
Date dateCompareTwo = parseDate("20:00");
if (dateCompareOne.before( date ) && dateCompareTwo.after(date)) {
//your logic
}
private Date parseDate(String date) {
final String inputFormat = "HH:mm";
SimpleDateFormat inputParser = new SimpleDateFormat(inputFormat, Locale.US);
try {
return inputParser.parse(date);
} catch (Java.text.ParseException e) {
return new Date(0);
}
}
De plus, pour être plus précis, Si vous comparez un temps entre un intervalle de plus de 00:00 à 24:00 de ce jour, Vous devez également analyser le jour.
Après avoir lu quelques réponses, je trouve que l'écriture est trop compliquée. Essayez mon code
public static boolean compare(String system_time, String currentTime, String endtimes) {
try {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss");
Date startime = simpleDateFormat.parse("19:25:00");
Date endtime = simpleDateFormat.parse("20:30:00");
//current time
Date current_time = simpleDateFormat.parse("20:00:00");
if (current_time.after(startime) && current_time.before(endtime)) {
System.out.println("Yes");
return true;
}
else if (current_time.after(startime) && current_time.after(endtime)) {
return true; //overlap condition check
}
else {
System.out.println("No");
return false;
}
} catch (ParseException e) {
e.printStackTrace();
}
return false;
}
La méthode suivante vérifie si "validateTime" se situe entre "startTime" et "endTime" ou non, tout en envisageant la possibilité que "endTime" puisse être un jour suivant. Pour l'utiliser correctement, analysez vos dates dans le formant "HH: mm".
public static final boolean isBetweenValidTime(Date startTime, Date endTime, Date validateTime)
{
boolean validTimeFlag = false;
if(endTime.compareTo(startTime) <= 0)
{
if(validateTime.compareTo(endTime) < 0 || validateTime.compareTo(startTime) >= 0)
{
validTimeFlag = true;
}
}
else if(validateTime.compareTo(endTime) < 0 && validateTime.compareTo(startTime) >= 0)
{
validTimeFlag = true;
}
return validTimeFlag;
}
Il me semble que votre problème est une OR situation ... Vous voulez vérifier si time1> 20:11:13 OR time1 <14:49:00.
Il n'y aura jamais de temps supérieur à 20:11:13 qui dépasse votre portée à l'autre bout (14:49:00) et vice-versa. Pensez-y comme si vous vérifiiez qu'une heure n'est PAS entre deux timestamps correctement commandés.
Utiliser LocalTime ignorerait simplement la valeur Date:
public class TimeIntervalChecker {
static final LocalTime time1 = LocalTime.parse( "20:11:13" ) ;
static final LocalTime time2 = LocalTime.parse( "14:49:00" ) ;
public static void main(String[] args) throws Java.lang.Exception {
LocalTime nowUtcTime = LocalTime.now(Clock.systemUTC());
if (nowUtcTime.isAfter(time1) && nowUtcTime.isBefore(time2)){
System.out.println(nowUtcTime+" is after: "+ time1+" and before: "+ time2);
}
}
La fonction de travail réelle sera comme suit
public static boolean isTimeBetweenTwoTime(Date startTime, Date stopTime, Date currentTime) {
//Start Time
Calendar StartTime = Calendar.getInstance();
StartTime.setTime(startTime);
//Current Time
Calendar CurrentTime = Calendar.getInstance();
CurrentTime.setTime(currentTime);
//Stop Time
Calendar StopTime = Calendar.getInstance();
StopTime.setTime(stopTime);
if (stopTime.compareTo(startTime) < 0) {
if (CurrentTime.compareTo(StopTime) < 0) {
CurrentTime.add(Calendar.DATE, 1);
}
StopTime.add(Calendar.DATE, 1);
}
return CurrentTime.compareTo(StartTime) >= 0 && CurrentTime.compareTo(StopTime) < 0;
}
désolé pour le code Sudo..Je suis sur un téléphone. ;)
between = (time < string2 && time > string1);
if (string1 > string2) between = !between;
si ce sont des horodatages ou des chaînes, cela fonctionne. il suffit de changer les noms de variables pour qu'ils correspondent
Comme avec l'aide de @kocko, le code de travail complet est comme ci-dessous:
try{
Date time11 = new SimpleDateFormat("HH:mm:ss").parse("20:11:13");
Calendar calendar1 = Calendar.getInstance();
calendar1.setTime(time11);
Date time22 = new SimpleDateFormat("HH:mm:ss").parse("14:49:00");
Calendar calendar2 = Calendar.getInstance();
calendar2.setTime(time22);
Date currentTime = new SimpleDateFormat("HH:mm:ss").parse("00:00:00");
Calendar startingCalendar = Calendar.getInstance();
startingCalendar.setTime(currentTime);
startingCalendar.add(Calendar.DATE, 1);
//let's say we have to check about 01:00:00
String someRandomTime = time1;
Date d = new SimpleDateFormat("HH:mm:ss").parse(someRandomTime);
Calendar calendar3 = Calendar.getInstance();
calendar3.setTime(d);
if(startingCalendar.getTime().after(calendar1.getTime()))
{
calendar2.add(Calendar.DATE, 1);
calendar3.add(Calendar.DATE, 1);
}
Date x = calendar3.getTime();
if (x.after(calendar1.getTime()) && x.before(calendar2.getTime()))
{
System.out.println("Time is in between..");
}
else
{
System.out.println("Time is not in between..");
}
} catch (ParseException e)
{
e.printStackTrace();
}
séparez les deux points des chaînes $ time, $ to et $ from, convertissez-les en int puis utilisez la condition suivante pour vérifier si le temps est compris entre de et à. L'exemple est en php, mais ne devrait pas avoir d'importance.
if(($to < $from && ($time >= $from || $time <= $to)) ||
($time >= $from && $time <= $to)) {
return true;
}
Dans votre cas, l'heure de début (20:11:13) est supérieure à l'heure de fin (14:49:00). Il est raisonnable de penser que vous pouvez résoudre le problème en ajoutant un jour à l'heure de fin ou en soustrayant un jour de l'heure de début. Si vous le faites, vous serez pris au piège car vous ne savez pas quel jour est l'heure du test.
Vous pouvez éviter cette interruption en vérifiant si votre heure de test est comprise entre l'heure de fin et l'heure de début. Si true, alors result est "pas entre les deux"; sinon le résultat est "bien entre les deux".
Voici la fonction en Java que j'utilise. Cela fonctionne jusqu'à présent pour moi. Bonne chance.
boolean IsTimeInBetween(Calendar startC, Calendar endC, Calendar testC){
// assume year, month and day of month are all equal.
startC.set(1,1,1);
endC.set(1,1,1);
testC.set(1,1,1);
if (endC.compareTo(startC) > 0) {
if ((testC.compareTo(startC)>=0) && (testC.compareTo(endC)<=0)) {
return true;
}else {
return false;
}
}else if (endC.compareTo(startC) < 0) {
if ((testC.compareTo(endC) >= 0) && (testC.compareTo(startC) <= 0)) {
return false;
} else {
return true;
}
} else{ // when endC.compareTo(startC)==0, I return a ture value. Change it if you have different application.
return true;
}
}
Pour créer une instance de calendrier, vous pouvez utiliser:
Calendar startC = Calendar.getInstance();
startC.set(Calendar.HOUR_OF_DAY, 20);
startC.set(Calendar.MINUTE,11);
startC.set(Calendar.SECOND,13);
Java 8 - LocalDateTime
Et ça?
final LocalDateTime now = LocalDateTime.now();
final LocalDateTime minRange = LocalDateTime.of(now.getYear(), now.getMonth(), now.getDayOfMonth(), 22, 30); //Today, 10:30pm
LocalDateTime maxRange = LocalDateTime.of(now.getYear(), now.getMonth(), now.getDayOfMonth(), 6, 30); //Tomorrow, 6:30am
maxRange = maxRange.plusDays(1); //Ensures that you don't run into an exception if minRange is the last day in the month.
if (now.isAfter(minRange) && now.isBefore(maxRange)) {
//Action
}
Dans l'extrait de code ci-dessous, il est vérifié que si l'heure actuelle (quelle qu'elle soit) existe ou non entre l'heure de début et de fin
Calendar startTimeCal = Calendar.getInstance();
startTimeCal.setTime(startTime);
int startTimeHour = startTimeCal.get(Calendar.HOUR_OF_DAY);
if (startTimeHour == 0){
startTimeHour = 24;
}
int startTimeMinutes = startTimeCal.get(Calendar.MINUTE);
Calendar curTimeCal = Calendar.getInstance();
curTimeCal.setTime(currentTime);
int curTimeHour = curTimeCal.get(Calendar.HOUR_OF_DAY);
int curTimeMinutes = curTimeCal.get(Calendar.MINUTE);
Calendar endTimeCal = Calendar.getInstance();
endTimeCal.setTime(endTime);
int endTimeHour = endTimeCal.get(Calendar.HOUR_OF_DAY);
if (endTimeHour == 0) {
endTimeHour = 24;
}
int endTimeMinutes = endTimeCal.get(Calendar.MINUTE);
if (((curTimeHour > startTimeHour) || (curTimeHour == startTimeHour && curTimeMinutes >= startTimeMinutes)) &&
((curTimeHour < endTimeHour) || (curTimeHour == endTimeHour && curTimeMinutes <= endTimeHour))) {
//time exists between start and end time
} else {
//time doesn't exist between start and end time
}
Je l'ai fait comme ça:
LocalTime time = LocalTime.now();
if (time.isAfter(LocalTime.of(02, 00)) && (time.isBefore(LocalTime.of(04, 00))))
{
log.info("Checking after 2AM, before 4AM!");
}
Modifier:
String time1 = "01:00:00";
String time2 = "15:00:00";
LocalTime time = LocalTime.parse(time2);
if ((time.isAfter(LocalTime.of(20,11,13))) || (time.isBefore(LocalTime.of(14,49,0))))
{
System.out.println("true");
}
else
{
System.out.println("false");
}
Logiquement, si vous faites ce qui suit, vous devriez toujours être d'accord car nous utilisons le temps militaire ...
si l’heure de début est supérieure à l’heure de fin, ajouter 24 à l’heure de fin .__ sinon utiliser les heures telles quelles
comparer l'heure actuelle entre les heures de début et de fin.
Voici une solution qui utilise les nouvelles classes Java 8, est compacte, ne nécessite aucune expression régulière ni opération arithmétique manuelle. Ma solution est codée pour startTime inclusif et endTime exclusif, mais peut facilement être modifiée pour répondre à vos besoins.
private boolean isTimeBetween(String timeToTest, String startTime, String endTime) {
LocalTime timeToTestDt = LocalTime.parse(timeToTest, DateTimeFormatter.ISO_LOCAL_TIME);
LocalTime startTimeDt = LocalTime.parse(startTime, DateTimeFormatter.ISO_LOCAL_TIME);
LocalTime endTimeDt = LocalTime.parse(endTime, DateTimeFormatter.ISO_LOCAL_TIME);
if(startTime.equals(endTime)) {
return false;
}
else if(startTimeDt.isBefore(endTimeDt)) { // Period does not cross the day boundary
return (timeToTest.equals(startTime) || timeToTestDt.isAfter(startTimeDt))
&& timeToTestDt.isBefore(endTimeDt);
} else { // Time period spans two days, e.g. 23:00 to 2:00
return (!((timeToTestDt.isAfter(endTimeDt) || timeToTest.equals(endTime))
&& timeToTestDt.isBefore(startTimeDt)));
}
}
// getTimeSpans() from the original question would then look like this
public void getTimeSpans()
{
boolean firstTime = isTimeBetween("01:00:00", "20:11:13", "14:49:00");
boolean secondTime = isTimeBetween("05:00:00", "20:11:13", "14:49:00");
}
Comme beaucoup de gens l’ont remarqué, ce n’est pas un problème de date, c’est un problème de logique… Supposons qu’un jour soit divisé en deux intervalles: l’un se situe entre 20:11:13 et 14:49:00, l’autre entre 14 et : 49: 00 et 20:11:13 (à vous de choisir l'intervalle auquel appartiennent les extrêmes) ... Si vous voulez vérifier si un certain temps est inclus dans le 20: 11: 13/14: 49: 00 , celle qui vous intéresse, vérifiez si elle est incluse dans l’autre, 14: 49: 00/20: 11: 13, ce qui est beaucoup plus facile en raison de l’ordre naturel des nombres, puis annulez le résultat.