Vérifier si un moment donné se trouve entre deux temps, peu importe la date

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

La java.les classes de temps comprennent LocalTime pour représenter un temps de jour seulement, sans date et sans un fuseau horaire.

Donc est ce que je veux, 20:11:13 < 01:00:00 < 14:49:00.

Nous avons d'abord définir les limites. Votre les chaînes d'entrée arriver à respecter la norme ISO 8601 formats. La java.les classes de temps utiliser le format ISO 8601 formats par défaut, donc pas besoin de spécifier le format.

LocalTime start = LocalTime.parse( "20:11:13" );
LocalTime stop = LocalTime.parse( "14:49:00" );

Et de définir notre scénario de test, la cible 01:00:00.

LocalTime target = LocalTime.parse( "01:00:00" );

Maintenant, nous sommes ensemble jusqu'à comparer ces LocalTime objets. Nous voulons voir si la cible est après le temps plus tard, mais avant le temps plus tôt. Que signifie milieu de la nuit, dans ce cas, environ entre 8 H et 3 h le lendemain matin.

Boolean isTargetAfterStartAndBeforeStop = ( target.isAfter( start ) && target.isBefore( stop ) ) ;

Que le test peut être plus simplement déclaré que “pas entre 3 heures et 8 heures”. On peut ensuite généraliser à n'importe quelle paire de LocalTime objets où nous les testons pour entre si le départ intervient avant l'arrêt avec une horloge de 24 heures, et pas entre si le départ intervient après l'arrêt (comme dans le cas de cette Question).

De plus, les intervalles de temps sont généralement traités avec la Demi-approche Ouverte où le début est inclusive alors que la fin est exclusif. Ainsi, un "entre" la comparaison, à proprement parler, serait “cible est égale à ou plus tard que le début ET la cible est avant de s'arrêter”, ou plus simplement, est la cible pas avant le départ ET avant l'arrêt”.

Boolean isBetweenStartAndStopStrictlySpeaking = 
    ( ( ! target.isBefore( start ) && target.isBefore( stop ) ) ;

Si le début est après l'arrêt, à l'intérieur d'une horloge de 24 heures, alors que nous voulons la logique suggérée dans la Question (est après 8 H, mais avant 3 heures du matin).

if( start.isAfter( stop ) ) {
    return ! isBetweenStartAndStopStrictlySpeaking ;
} else {
    return isBetweenStartAndStopStrictlySpeaking ;
}

---

Sur java.temps

La java.temps cadre est intégré dans Java 8 et les versions ultérieures. Ces classes permettent d'éviter la pénible vieux héritage date du temps des classes comme java.util.Date, Agenda, & SimpleDateFormat.

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

Pour en savoir plus, consultez les Oracle Tutoriel. Et de recherche de Débordement de Pile pour de nombreux exemples et des explications. La spécification est JSR 310.

Vous pouvez échanger java.temps objets directement avec votre base de données. Utiliser un Pilote JDBC compatible avec JDBC 4.2 ou plus tard. Pas besoin de chaînes, pas besoin de java.sql.* classes.

Où obtenir le java.les classes de temps?

• Java SE 8, Java SE 9, Java SE 10, et plus tard
  • Intégré.
  • Partie de la norme API Java avec une liasse de mise en œuvre.
  • Java 9 ajoute quelques fonctionnalités mineures et corrections.
• Java SE 6 et Java SE 7
  • Une grande partie de la java.fonction temps est de retour, porté à Java 6 & 7 dans ThreeTen-Backport.
• Android
  • Plus tard, des versions d'Android bundle implémentations de java.les classes de temps.
  • Antérieures d'Android (<26), le ThreeTenABP projet s'adapte ThreeTen-Backport (mentionné ci-dessus). Voir Comment utiliser ThreeTenABP....

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 Intervalle, YearWeek, YearQuarter, et plus.

Modifié @Surendra Jnawali code. Il ne parvient pas

si l'heure actuelle est 23:40:00 je.e de plus que l'heure de début et moins égal à 23:59:59.

Tout le crédit va à la véritable propriétaire

C'est comment il 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É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

Il y a beaucoup de réponses ici, mais je tiens à donner un nouveau qui est similaire avec Le basilic Bourque réponse mais avec un exemple de code. Merci donc de voir la méthode ci-dessous:

private static void checkTime(String startTime, String endTime, String checkTime) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss", Locale.US);
LocalTime startLocalTime = LocalTime.parse(startTime, formatter);
LocalTime endLocalTime = LocalTime.parse(endTime, formatter);
LocalTime checkLocalTime = LocalTime.parse(checkTime, formatter);
boolean isInBetween = false;
if (endLocalTime.isAfter(startLocalTime)) {
if (startLocalTime.isBefore(checkLocalTime) && endLocalTime.isAfter(checkLocalTime)) {
isInBetween = true;
}
} else if (checkLocalTime.isAfter(startLocalTime) || checkLocalTime.isBefore(endLocalTime)) {
isInBetween = true;
}
if (isInBetween) {
System.out.println("Is in between!");
} else {
System.out.println("Is not in between!");
}
}

Soit si vous êtes à l'appel de cette méthode à l'aide de:

checkTime("20:11:13", "14:49:00", "01:00:00");

Ou à l'aide de:

checkTime("20:11:13", "14:49:00", "05:00:00");

Le résultat sera:

Is in between!

À l'aide de LocalTime voudrais simplement ignorer la valeur de 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);
} 
}

Après avoir lu quelques réponses, je sens que l'écriture est trop compliqué. 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;
} 

Le travail Effectif de la fonction 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;
}

Java 8 - LocalDateTime

Quoi à ce sujet?

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
}

J'ai fait de cette façon:

LocalTime time = LocalTime.now();
if (time.isAfter(LocalTime.of(02, 00)) && (time.isBefore(LocalTime.of(04, 00))))
{
log.info("Checking after 2AM, before 4AM!");                    
}

Edit:

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

bande de colons de l' $heure, $et $de chaînes, de les convertir en int et ensuite utiliser la condition suivante pour vérifier si le temps est entre de et de. Exemple est en php, mais ne compte pas.

if(($to < $from && ($time >= $from || $time <= $to)) ||
($time >= $from && $time <= $to)) {
return true;
}

Logiquement, si vous effectuez les opérations suivantes, vous devez toujours être ok accordée, nous utilisons l'heure militaire...

si l'heure de début est plus que temps de la fin, ajouter les 24 à la fin des temps
d'autre fois comme le

comparer les temps pour être dans l'intervalle de début et de fin des temps.

Sur la base des idées et des solutions de la plupart des auteurs ici, je voudrais partager ma raffiné solution sans doute plus propre code:

    /**
* Checks if some date is within a time window given by start and end dates
*
* @param checkDate - date to check if its hours and minutes is between the startDate and endDate
* @param startDate - startDate of the time window
* @param endDate - endDate of the time window
* @return - returns true if hours and minutes of checkDate is between startDate and endDate
*/
public static boolean isDateBetweenStartAndEndHoursAndMinutes(Date checkDate, Date startDate, Date endDate) {
if (startDate == null || endDate == null)
return false;
LocalDateTime checkLdt = LocalDateTime.ofInstant(Instant.ofEpochMilli(checkDate.getTime()), ZoneId.systemDefault());
LocalDateTime startLdt = LocalDateTime.ofInstant(Instant.ofEpochMilli(startDate.getTime()), ZoneId.systemDefault());
LocalDateTime endLdt = LocalDateTime.ofInstant(Instant.ofEpochMilli(endDate.getTime()), ZoneId.systemDefault());
//Table of situations:
//Input dates: start (a), end (b), check (c)
//Interpretations:
//t(x) = time of point x on timeline; v(x) = nominal value of x
//Situation A - crossing midnight:
//c INSIDE
//     1) t(a) < t(c) < t(b) | v(b) < v(a) < v(c) //e.g. a=22:00, b=03:00, c=23:00 (before midnight)
//     2) t(a) < t(c) < t(b) | v(c) < v(b) < v(a) //e.g. a=22:00, b=03:00, c=01:00 (after midnight)
//c OUTSIDE
//     3) t(c) < t(a) < t(b) | v(b) < v(c) < v(a) //e.g. a=22:00, b=03:00, c=21:00
//     4) t(a) < t(b) < t(c) | v(b) < v(c) < v(a) //e.g. a=22:00, b=03:00, c=04:00
//                             ^--- v(b) < v(a) always when shift spans around midnight!
//Situation B - after/before midnight:
//c INSIDE
//     1) t(a) = t(c) < t(b) | v(a) = v(c) < v(b) //e.g. a=06:00, b=14:00, c=06:00
//     2) t(a) < t(c) < t(b) | v(a) < v(c) < v(b) //e.g. a=06:00, b=14:00, c=08:00
//c OUTSIDE
//     3) t(c) < t(a) < t(b) | v(c) < v(a) < v(b) //e.g. a=06:00, b=14:00, c=05:00
//     4) t(a) < t(b) = t(c) | v(a) < v(b) = v(c) //e.g. a=06:00, b=14:00, c=14:00
//     5) t(a) < t(b) < t(c) | v(a) < v(b) < v(c) //e.g. a=06:00, b=14:00, c=15:00
//                             ^--- v(a) < v(b) if shift starts after midnight and ends before midnight!
//Check for situation A - crossing midnight?
boolean crossingMidnight = endLdt.isBefore(startLdt);
if (crossingMidnight) {
//A.1
if ((startLdt.isBefore(checkLdt) || startLdt.isEqual(checkLdt))  //t(a) < t(c)
&& checkLdt.isBefore(endLdt.plusDays(1))) //t(c) < t(b+1D)
return true;
//A.2
if (startLdt.isBefore(checkLdt.plusDays(1))   //t(a) < t(c+1D)
&& checkLdt.isBefore(endLdt)) //t(c) < t(b)
return true;
//A.3
if (startLdt.isBefore(endLdt.plusDays(1))   //t(a) < t(b+1D)
&& checkLdt.isBefore(startLdt)) //t(c) < t(a)
return false;
//A.4
if (startLdt.isBefore(endLdt.plusDays(1))   //t(a) < t(b+1D)
&& checkLdt.isAfter(endLdt)) //t(b) < t(c)
return false;
} else {
//B.1 + B.2
if ((startLdt.isEqual(checkLdt) || startLdt.isBefore(checkLdt))  //t(a) = t(c) || t(a) < t(c)
&& checkLdt.isBefore(endLdt)) //t(c) < t(b)
return true;
}
return false;
}

Par souci d'exhaustivité, j'ai ajouté les conditions de A. 3 et A. 4, mais dans la production de code, vous pouvez les laisser.

Maintenant, vous pouvez tout simplement créer votre début et date de fin, ainsi que le temps que vous voulez vérifier et d'appeler cette méthode statique. Le code devrait aller, puis comme suit:

Date check = new SimpleDateFormat("HH:mm:ss").parse("01:00:00");
Date start = new SimpleDateFormat("HH:mm:ss").parse("20:11:13");
Date end = new SimpleDateFormat("HH:mm:ss").parse("14:49:00");
if (isDateBetweenStartAndEndHoursAndMinutes(check, start, end)) {
Print("checkDate is within start and End date!"); //adjust this true condition to your needs
}

Pour le TDD aspect, j'ai ajouté des tests unitaires pour les scénarios A et B ci-dessus. N'hésitez pas à les tester et de les rapporter si vous trouvez des erreurs ou des spots pour l'optimisation.

import org.junit.jupiter.api.Test;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
class LogiqDateUtilsTest  {
private LocalDateTime startShiftSituationALdt = LocalDateTime.of(0, 1, 1, 22, 0);
private Date startOfShiftSituationA = Date.from(startShiftSituationALdt.atZone(ZoneId.systemDefault()).toInstant());
private LocalDateTime endShiftSituationALdt = LocalDateTime.of(0, 1, 1, 3, 0);
private Date endOfShiftSituationA = Date.from(endShiftSituationALdt.atZone(ZoneId.systemDefault()).toInstant());
private LocalDateTime startShiftSituationBLdt = LocalDateTime.of(0, 1, 1, 6, 0);
private Date startOfShiftSituationB = Date.from(startShiftSituationBLdt.atZone(ZoneId.systemDefault()).toInstant());
private LocalDateTime endShiftSituationBLdt = LocalDateTime.of(0, 1, 1, 14, 0);
private Date endOfShiftSituationB = Date.from(endShiftSituationBLdt.atZone(ZoneId.systemDefault()).toInstant());
@Test
void testSituationA1() {
LocalDateTime checkLdt = LocalDateTime.of(0, 1, 1, 23, 0);
Date checkBetween = Date.from(checkLdt.atZone(ZoneId.systemDefault()).toInstant());
assertTrue(isDateBetweenStartAndEndHoursAndMinutes(checkBetween, startOfShiftSituationA, endOfShiftSituationA));
}
@Test
void testSituationA2() {
LocalDateTime checkLdt = LocalDateTime.of(0, 1, 1, 1, 0);
Date checkBetween = Date.from(checkLdt.atZone(ZoneId.systemDefault()).toInstant());
assertTrue(isDateBetweenStartAndEndHoursAndMinutes(checkBetween, startOfShiftSituationA, endOfShiftSituationA));
}
@Test
void testSituationA3() {
LocalDateTime checkLdt = LocalDateTime.of(0, 1, 1, 21, 1);
Date checkBetween = Date.from(checkLdt.atZone(ZoneId.systemDefault()).toInstant());
assertFalse(isDateBetweenStartAndEndHoursAndMinutes(checkBetween, startOfShiftSituationA, endOfShiftSituationA));
}
@Test
void testSituationA4() {
LocalDateTime checkLdt = LocalDateTime.of(0, 1, 1, 4, 1);
Date checkBetween = Date.from(checkLdt.atZone(ZoneId.systemDefault()).toInstant());
assertFalse(isDateBetweenStartAndEndHoursAndMinutes(checkBetween, startOfShiftSituationA, endOfShiftSituationA));
}
@Test
void testSituationB1() {
LocalDateTime checkLdt = LocalDateTime.of(0, 1, 1, 6, 0);
Date checkBetween = Date.from(checkLdt.atZone(ZoneId.systemDefault()).toInstant());
assertTrue(isDateBetweenStartAndEndHoursAndMinutes(checkBetween, startOfShiftSituationB, endOfShiftSituationB));
}
@Test
void testSituationB2() {
LocalDateTime checkLdt = LocalDateTime.of(0, 1, 1, 8, 0);
Date checkBetween = Date.from(checkLdt.atZone(ZoneId.systemDefault()).toInstant());
assertTrue(isDateBetweenStartAndEndHoursAndMinutes(checkBetween, startOfShiftSituationB, endOfShiftSituationB));
}
@Test
void testSituationB3() {
LocalDateTime checkLdt = LocalDateTime.of(0, 1, 1, 5, 0);
Date checkBetween = Date.from(checkLdt.atZone(ZoneId.systemDefault()).toInstant());
assertFalse(isDateBetweenStartAndEndHoursAndMinutes(checkBetween, startOfShiftSituationB, endOfShiftSituationB));
}
@Test
void testSituationB4() {
LocalDateTime checkLdt = LocalDateTime.of(0, 1, 1, 14, 0);
Date checkBetween = Date.from(checkLdt.atZone(ZoneId.systemDefault()).toInstant());
assertFalse(isDateBetweenStartAndEndHoursAndMinutes(checkBetween, startOfShiftSituationB, endOfShiftSituationB));
}
@Test
void testSituationB5() {
LocalDateTime checkLdt = LocalDateTime.of(0, 1, 1, 15, 0);
Date checkBetween = Date.from(checkLdt.atZone(ZoneId.systemDefault()).toInstant());
assertFalse(isDateBetweenStartAndEndHoursAndMinutes(checkBetween, startOfShiftSituationB, endOfShiftSituationB));
}
}

Cheers!