无论日期如何，检查给定时间是不是介于两次之间
Posted
技术标签:
【中文标题】无论日期如何，检查给定时间是不是介于两次之间【英文标题】：Check if a given time lies between two times regardless of date无论日期如何，检查给定时间是否介于两次之间 【发布时间】：2013-07-15 21:28:59 【问题描述】：我有时间跨度：
字符串时间1 = 01:00:00
字符串时间2 = 05:00:00
我想检查 time1 和 time2 是否都在20:11:13 and 14:49:00 之间。
实际上，考虑到20:11:13 总是小于14:49:00，01:00:00 大于20:11:13 并且小于14:49:00。这是先决条件。
所以我想要的是，20:11:13 < 01:00:00 < 14:49:00。
所以我需要这样的东西：
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;
我知道这段代码在比较字符串对象时没有给出正确的结果。
如何做到这一点，因为它们是时间跨度而不是要比较的字符串？
【问题讨论】：
如果不考虑日期，这怎么可能是真的？如果一个时间大于20:11:13，如果不可能小于14:49:00。 @jalynn2 - 抱歉不清楚。实际上，考虑到20:11:13 总是小于14:49:00，01:00:00 大于20:11:13 并且小于14:49:00。这是先决条件。
如果你给出的格式是 HH:MM:SS，那么01:00:00 在同一天不会大于20:11:13，并且20:11:13 永远不会小于14:49:00。如果您想确定时间是否在一天的20:11:13 和第二天的14:49:00 之间，那么您需要在比较中引入一个日期。
不考虑日期难道不可以，因为20:11:13 总是小于14:49:00 吗？
20 > 14，不是吗？所以20:11:13 大于14:49:00。 “下午 3 点前 11 分钟”不迟于当天的“晚上 8 点后 11 分钟”。我错过了什么？
【参考方案1】：
您可以使用Calendar 类进行检查。
例如：
try
String string1 = "20:11:13";
Date time1 = new SimpleDateFormat("HH:mm:ss").parse(string1);
Calendar calendar1 = Calendar.getInstance();
calendar1.setTime(time1);
calendar1.add(Calendar.DATE, 1);
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();
【讨论】：
那么你必须在某处标记那些时间不在同一天！ 除非您检查的时间是23:00:00。您需要关联一个日期，或者您需要检查时间是否在20:11:13 和24:00:00 之间或00:00:00 和14:49:00 之间
我也使用Date currentTime = new SimpleDateFormat("HH:mm:ss").parse("00:00:00"); Calendar calendar = Calendar.getInstance(); calendar.setTime(currentTime); calendar.add(Calendar.DATE, 1); 进行了剩余的比较。让我检查一下。
如果 someRandomTime 位于 string1 和 "00:00:00" 之间，这可能会给出错误的答案。如果我错了，请纠正我。
它显示的 11:44 介于 19:28 到 23:59 之间......任何解决方案。【参考方案2】：
tl;博士
20:11:13
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
java.time 类包括 LocalTime，仅表示没有日期和时区的时间。
所以我想要的是，20:11:13
首先我们定义边界。您的输入字符串恰好符合标准ISO 8601 格式。 java.time 类默认使用 ISO 8601 格式，因此无需指定格式模式。
LocalTime start = LocalTime.parse( "20:11:13" );
LocalTime stop = LocalTime.parse( "14:49:00" );
并定义我们的测试用例，目标01:00:00。
LocalTime target = LocalTime.parse( "01:00:00" );
现在我们准备比较这些LocalTime 对象。我们想看看目标是否在较晚的时间之后但在较早的时间之前。在这种情况下，这意味着半夜，大约在晚上 8 点到第二天早上 3 点之间。
Boolean isTargetAfterStartAndBeforeStop = ( target.isAfter( start ) && target.isBefore( stop ) ) ;
该测试可以更简单地表述为“不是在凌晨 3 点到晚上 8 点之间”。然后我们可以推广到任何一对LocalTime 对象，如果开始在 24 小时制的停止之前，我们测试 between，如果开始在 not between在停止之后出现（就像这个问题一样）。
此外，时间跨度通常使用半开放方法处理，其中开始是包含，而结尾是独占。因此，严格来说，“介于”比较将是“目标是否等于或晚于开始且目标在停止之前”，或者更简单地说，“目标是否在开始之前且在停止之前”。
Boolean isBetweenStartAndStopStrictlySpeaking =
( ( ! target.isBefore( start ) && target.isBefore( stop ) ) ;
如果开始是在停止之后，在 24 小时内，那么假设我们想要问题中建议的逻辑（晚上 8 点之后但凌晨 3 点之前）。
if( start.isAfter( stop ) )
return ! isBetweenStartAndStopStrictlySpeaking ;
else
return isBetweenStartAndStopStrictlySpeaking ;
关于java.time
java.time 框架内置于 Java 8 及更高版本中。这些类取代了麻烦的旧 legacy 日期时间类，例如 java.util.Date、Calendar 和 SimpleDateFormat。
要了解更多信息，请参阅Oracle Tutorial。并在 Stack Overflow 上搜索许多示例和解释。规格为JSR 310。
Joda-Time 项目现在位于maintenance mode，建议迁移到java.time 类。
您可以直接与您的数据库交换 java.time 对象。使用符合JDBC 4.2 或更高版本的JDBC driver。不需要字符串，不需要java.sql.* 类。 Hibernate 5 & JPA 2.2 支持 java.time。
从哪里获取 java.time 类？
Java SE 8、Java SE 9、Java SE 10、Java SE 11 和更高版本 - 具有捆绑实现的标准 Java API 的一部分。 Java 9 带来了一些小功能和修复。 Java SE 6 和 Java SE 7 大部分 java.time 功能在ThreeTen-Backport 中向后移植到 Java 6 和 7。 Android java.time 类的更高版本的 android (26+) 捆绑实现。 对于早期的 Android (API desugaring 的进程带来了最初未内置于 Android 中的subset of the java.time 功能。 如果脱糖不能满足您的需求，ThreeTenABP 项目会将ThreeTen-Backport（如上所述）适配到 Android。见How to use ThreeTenABP…。【讨论】：
这不适用于目标时间 18:00，开始时间是 21:00，停止时间是 03:00。在这种情况下，目标不在开始之前，但目标也不在停止之前。所以 isBetweenStartAndStopStrctlySpeaking 是假的。由于开始是在停止之后，我们否定它，这等于说 18:00 介于 21:00 和 03:00 之间，这是错误的。 @thisisananth 你已经颠覆了问题的逻辑。该问题特别询问目标是否是after较晚时间和before较早时间：所以我想要的是，20:11:13 。因此，在您的示例中，18:00（下午 6 点）不是介于 21:00 和 03:00 之间，而凌晨 1 点是介于晚上 9 点和凌晨 3 点之间。无论哪种逻辑由您的业务逻辑决定，翻转我的代码的布尔逻辑。但是您不能同时将凌晨 1 点和下午 6 点都放在傍晚和早上中午之间——问“介于两者之间”的问题是没有意义的。【参考方案3】：@kocko 给出的答案仅在同一天有效。 如果开始时间 "23:00:00" 和结束时间 "02:00:00"[第二天] 并且当前时间是 "01:30:00 " 则结果为假... 我修改了 @kocko's answer 使其完美运行
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");
输出
"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
（我已将下限值包含到[上限值-1]）
【讨论】：
这是最好的答案@Surendra Jnawali 如果当前时间是 23:40:00，即大于开始时间且小于等于 23:59:59，这也会失败。 @David，对不起，我没有找到你。您能否提供不满意结果的当前、开始和结束时间。所以如果有什么问题我会解决.... @SurendraJnawali 当然，请试试这个 "23:00:00" - "06:00:00" - "23:40:00" [current] - false 。我还发布了更新您的答案的答案。当然，所有功劳都归你所有。 这不能正常工作！来自 Jitender Dev 的更正了【参考方案4】：修改了@Surendra Jnawali 的代码。失败了
如果当前时间是 23:40:00，即大于开始时间且小于等于 23:59:59。
所有功劳归真正所有者所有
应该是这样的：这很完美
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");
结果
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
【讨论】：
【参考方案5】： 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);
进一步，更准确地说， 如果您比较当日 00:00 到 24:00 之间的时间间隔， 你也需要解析这一天。
【讨论】：
这是有史以来最好和最可靠的答案之一。我会推荐每个人都试试这个。早些时候，我使用 Calendar 对象通过 after 和 before 方法检查当前时间。结果令人困惑，有时它是正确的，有时它是错误的。例如：上午 7:00 不是在上午 7:00 之后，而是使用日历对象将状态设为真，有时为假。 这些糟糕的日期时间类在几年前被 JSR 310 采用的 java.time 类所取代。【参考方案6】：这里有很多答案，但我想提供一个与Basil Bourque's answer 类似但带有完整代码示例的新答案。所以请看下面的方法：
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!");
如果您正在使用以下方法调用此方法：
checkTime("20:11:13", "14:49:00", "01:00:00");
或使用：
checkTime("20:11:13", "14:49:00", "05:00:00");
结果将是：
Is in between!
【讨论】：
简洁优雅！非常感谢！ 我尝试将它用于我的 Android 应用程序，它说它仅适用于 Api26+ ，有人可以帮忙吗？ @AlexMamo 哪个变了？ @AlexMamo 是的，当然它会为 api 26 及更高版本运行，但我想支持到 android lollipop(api 21) 最佳而简单的答案【参考方案7】：以下方法检查 'validateTime' 是否在 'startTime' 和 'endTime' 之间，同时考虑 'endTime' 可能是第二天的可能性。要正确使用它，请在“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;
【讨论】：
【参考方案8】：Java 8 - LocalDateTime
这个怎么样？
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
【讨论】：
此代码涉及日期，但问题只要求提供时间，没有任何日期。【参考方案9】：使用 LocalTime 只会忽略 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);
【讨论】：
(a) 看起来很像my Answer。我看不到任何附加值。 (b) 不需要传递Clock.systemUTC()，因为这是没有传递参数时的默认值。只需使用：Instant.now().
是的，可能看起来像你的，但如果我们只是想检查给定时间是否介于两个时间之间，无论日期如何，就可以不那么冗长了。 Clock.systemUTC() 用于将 UTC 时区用于当前日期，否则默认使用本地时区。
您对传递时钟的需要是不正确的。该文档明确表示 UTC 是默认设置，您需要传递一个时钟仅用于使用错误/更改的时钟进行测试。您将 Instant.now 与其他类的 .now 方法混淆了，如果省略，它们确实使用 JVM 的当前默认时区。【参考方案10】：
看了几个回复，感觉写的太复杂了。试试我的代码
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;
【讨论】：
您正在使用麻烦的旧类，这些旧类现在已被 java.time 类取代。【参考方案11】：在@kocko的帮助下，完整的工作代码如下：
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();
【讨论】：
【参考方案12】：在我看来，您的问题是 OR 情况...您想检查 time1 > 20:11:13 OR time1
永远不会有超过 20:11:13 的时间超过您在另一端 (14:49:00) 的范围，反之亦然。可以将其想象为您正在检查时间是否不在正确排序的几个时间戳之间。
【讨论】：
【参考方案13】：实际工作功能如下
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;
【讨论】：
你真的应该避免使用大写来命名变量。【参考方案14】：在您的情况下，开始时间 (20:11:13) 大于结束时间 (14:49:00)。一个合理的假设是，您可以通过在结束时间增加一天或从开始时间减少一天来解决问题。如果这样做，您将被困，因为您不知道测试时间是哪一天。
您可以通过检查您的测试时间是否在结束时间和开始时间之间来避免这个陷阱。如果为真，则结果为“不在两者之间”；否则结果是“介于两者之间”。
这是我一直在使用的 JAVA 中的函数。到目前为止它对我有用。祝你好运。
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;
要创建日历实例，您可以使用：
Calendar startC = Calendar.getInstance();
startC.set(Calendar.HOUR_OF_DAY, 20);
startC.set(Calendar.MINUTE,11);
startC.set(Calendar.SECOND,13);
【讨论】：
【参考方案15】：在下面的代码片段中，正在验证当前时间（可以是任何时间）是否存在于开始时间和结束时间之间：
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
【讨论】：
【参考方案16】：正如许多人所注意到的，这不是日期问题，而是逻辑问题。 假设一天分为两个时间段：一个位于 20:11:13 和 14:49:00 之间，而另一个位于 14:49:00 和 20:11:13 之间（极端属于哪个时间段）你）。 如果您想检查某个时间是否包含在 20:11:13/14:49:00 一个，您感兴趣的那个，只需检查它是否包含在另一个 14:49:00/ 中20:11:13，这要容易得多，因为数字的自然顺序，然后否定结果。
【讨论】：
【参考方案17】：我是这样做的：
LocalTime time = LocalTime.now();
if (time.isAfter(LocalTime.of(02, 00)) && (time.isBefore(LocalTime.of(04, 00))))
log.info("Checking after 2AM, before 4AM!");
编辑：
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");
【讨论】：
这个答案如何比使用LocalTime 的现有答案提供价值？
很好地演示了LocalTime 的使用，但似乎并没有真正回答所问的问题。还要避免前缀零：它们适用于00、02 和04，但不适用于08 和09。
老兄，我很感谢您的反馈，但这就是我有时不喜欢 Stack 的原因：那些不是八进制数，这里没有其他人在使用 LocalTime.of
@ghita 对于早期的 Android，请参阅改编 ThreeTen-Backport 项目的 ThreeTenABP 项目。
@JasonH 你错了：以零开头的整数文字，例如02 代表octal（base-8）数字。见section 3.10.1 of the Java Language Specification。【参考方案18】：
这是一个使用新的 Java 8 类的解决方案，结构紧凑，不需要正则表达式或手动算术运算。我的解决方案针对包含 startTime 和独占 endTime 进行了编码，但可以根据您的需要轻松修改。
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");
【讨论】：
【参考方案19】：所有差距的简单解决方案：
public boolean isNowTimeBetween(String startTime, String endTime)
LocalTime start = LocalTime.parse(startTime);//"22:00"
LocalTime end = LocalTime.parse(endTime);//"10:00"
LocalTime now = LocalTime.now();
if (start.isBefore(end))
return now.isAfter(start) && now.isBefore(end);
return now.isBefore(start)
? now.isBefore(start) && now.isBefore(end)
: now.isAfter(start) && now.isAfter(end);
【讨论】：
使用LocalTime很好，我同意。我觉得你的逻辑不是那么简单易懂，而且它当然可以更简单。【参考方案20】：
从 $time、$to 和 $from 字符串中去掉冒号，转换为 int，然后使用以下条件检查时间是否在 from 和 to 之间。示例在 php 中，但不重要。
if(($to < $from && ($time >= $from || $time <= $to)) ||
($time >= $from && $time <= $to))
return true;
【讨论】：
看不到这个 PHP 特定的答案如何帮助 OP。【参考方案21】：从逻辑上讲，如果您执行以下操作，您应该总是可以接受我们使用军事时间...
如果开始时间大于结束时间，则将 24 添加到结束时间 否则按原样使用时间
比较当前时间以在开始时间和结束时间之间。
【讨论】：
【参考方案22】：根据这里大多数作者的想法和解决方案，我想用一个大概更干净的代码分享我的改进解决方案：
/**
* 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;
为了完整起见，我添加了 A.3 和 A.4 的条件，但在生产代码中您可以省略它。
现在您可以简单地创建您的开始和结束日期，以及您想要检查的时间并调用此静态方法。代码如下：
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
对于 TDD 方面，我已经为上面给出的场景 A 和 B 添加了单元测试。如果您发现任何错误或需要优化的地方，请随时检查并报告。
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));
干杯！
【讨论】：
【参考方案23】：/**
* @param initialTime - in format HH:mm:ss
* @param finalTime - in format HH:mm:ss
* @param timeToCheck - in format HH:mm:ss
* @return initialTime <= timeToCheck < finalTime
* @throws IllegalArgumentException if passed date with wrong format
*/
public static boolean isTimeBetweenTwoTime(String initialTime, String finalTime, String timeToCheck) throws IllegalArgumentException
String reg = "^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$";
if (initialTime.matches(reg) && finalTime.matches(reg) && timeToCheck.matches(reg))
SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss", Locale.getDefault());
Date inTime = parseDate(dateFormat, initialTime);
Date finTime = parseDate(dateFormat, finalTime);
Date checkedTime = parseDate(dateFormat, timeToCheck);
if (finalTime.compareTo(initialTime) < 0)
Calendar calendar = Calendar.getInstance();
calendar.setTime(finTime);
calendar.add(Calendar.DAY_OF_YEAR, 1);
finTime = calendar.getTime();
if (timeToCheck.compareTo(initialTime) < 0)
calendar.setTime(checkedTime);
calendar.add(Calendar.DAY_OF_YEAR, 1);
checkedTime = calendar.getTime();
return (checkedTime.after(inTime) || checkedTime.compareTo(inTime) == 0) && checkedTime.before(finTime);
else
throw new IllegalArgumentException("Not a valid time, expecting HH:MM:SS format");
/**
* @param initialTime - in format HH:mm:ss
* @param finalTime - in format HH:mm:ss
* @return initialTime <= now < finalTime
* @throws IllegalArgumentException if passed date with wrong format
*/
public static boolean isNowBetweenTwoTime(String initialTime, String finalTime) throws IllegalArgumentException
return isTimeBetweenTwoTime(initialTime, finalTime,
String.valueOf(DateFormat.format("HH:mm:ss", new Date()))
);
private static Date parseDate(SimpleDateFormat dateFormat, String data)
try
return dateFormat.parse(data);
catch (ParseException e)
throw new IllegalArgumentException("Not a valid time");
【讨论】：
请不要教年轻人使用早已过时且臭名昭著的SimpleDateFormat类。至少不是第一选择。而且不是没有任何保留。今天我们在java.time, the modern Java date and time API, 和它的DateTimeFormatter 中做得更好。另外，例如，BasilBourque 的答案仅用 6 行简单而简短的行就获得了它的意义何在？【参考方案24】：
这对我有用：
fun timeBetweenInterval(
openTime: String,
closeTime: String
): Boolean
try
val dateFormat = SimpleDateFormat(TIME_FORMAT)
val afterCalendar = Calendar.getInstance().apply
time = dateFormat.parse(openTime)
add(Calendar.DATE, 1)
val beforeCalendar = Calendar.getInstance().apply
time = dateFormat.parse(closeTime)
add(Calendar.DATE, 1)
val current = Calendar.getInstance().apply
val localTime = dateFormat.format(timeInMillis)
time = dateFormat.parse(localTime)
add(Calendar.DATE, 1)
return current.time.after(afterCalendar.time) && current.time.before(beforeCalendar.time)
catch (e: ParseException)
e.printStackTrace()
return false
【讨论】：
【参考方案25】：基于 Konstantin_Yovkov answer 我想分享我的实现，它检查当前时间是否在给定的 START 和 END 时间之间。
这个实现假设如果给定的 END 时间在 START 时间之前，那么 END 必须是明天：
public static boolean currentTimeInBetween(String start, String end)
throws ParseException
// start = "15:25";
java.util.Date starttime = new SimpleDateFormat("HH:mm").parse(start);
Calendar startcal = Calendar.getInstance();
startcal.setTime(starttime);
// end = "14:00";
java.util.Date endtime = new SimpleDateFormat("HH:mm").parse(end);
Calendar endcal = Calendar.getInstance();
endcal.setTime(endtime);
DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
java.util.Date currenttime = dateFormat
.parse(dateFormat.format(new java.util.Date()));
Calendar currentcal = Calendar.getInstance();
currentcal.setTime(currenttime);
// If endTime < startTime, assume that endTime is 'tomorrow'
if (startcal.after(endcal))
endcal.add(Calendar.DATE, 1);
// System.out.println("START" + " System Date: " + startcal.getTime());
// System.out.println("END" + " System Date: " + endcal.getTime());
// System.out.println("Current" + " System Date: " + currentcal.getTime());
java.util.Date current = currentcal.getTime();
if (current.after(startcal.getTime())
&& current.before(endcal.getTime()))
return true;
else
return false;
【讨论】：
我对这些假设很好，当它们在这里明确时更是如此。请不要教年轻人使用陈旧且臭名昭著的SimpleDateFormat类。至少不是第一选择。而且不是没有任何保留。我们在java.time, the modern Java date and time API, 和它的DateTimeFormatter 中做得更好。【参考方案26】：
用 Kotlin 编写的求解函数
/**
* @param currentTime : Time to compare
* @param startTime: Start Hour in format like 10:00:00
* @param endTime: End Hour in format like 15:45:00
*/
fun isTimeInBetweenHours(currentDate: Date, startTime: String, endTime: String): Boolean
val simpleDateFormat = SimpleDateFormat("HH:mm:ss", Locale.US)
try
val startTimeCalendar = Calendar.getInstance()
startTimeCalendar.time = simpleDateFormat.parse(startTime)
startTimeCalendar.add(Calendar.DATE, 1)
val endTimeCalendar = Calendar.getInstance()
endTimeCalendar.time = simpleDateFormat.parse(endTime)
endTimeCalendar.add(Calendar.DATE, 1)
val currentTime = simpleDateFormat.format(currentDate) //"01:00:00"
val currentTimeCalendar = Calendar.getInstance()
currentTimeCalendar.time = simpleDateFormat.parse(currentTime)
currentTimeCalendar.add(Calendar.DATE, 1)
val x = currentTimeCalendar.time
return x.after(startTimeCalendar.time) && x.before(endTimeCalendar.time)
catch (e: ParseException)
return false
格式化程序只接受 HH:mm:ss，因此它与日期无关。所有日期都计算为 1970 年 1 月 1 日作为纪元开始日期。因此，时间的比较只发生在时间上，因为这里所有案例的日期都是 1970 年 1 月 1 日。
注意：使用旧版 Java API，而不是较新的 API（LocalTime 和 DateTimeFormatter），因为这些较新的 API 在旧设备（如 Android 版本 Oreo 以下）上不受支持。如果您正在使用可以获取更新 API 的其他平台，请使用它们，因为它们更优化且错误更少。
【讨论】：
我建议你不要使用Calendar 和SimpleDateFormat。这些类设计不佳且过时，尤其是后者出了名的麻烦。而是使用来自java.time, the modern Java date and time API 的LocalTime 和DateTimeFormatter。此外，我发现您的代码甚至比 Calendar 所需要的更令人困惑。一些解释可能会帮助这部分。而且我不相信它尊重 不管日期 部分。
格式化程序只接受 HH:mm:ss，因此它与日期无关。所有日期都计算为 1970 年 1 月 1 日作为纪元开始日期。因此，时间的比较只发生在时间上，因为这里所有案例的日期都是 1970 年 1 月 1 日。【参考方案27】：
我已经在 kotlin 中实现了它，它按预期工作：
fun isInBetween(startTime: String, endTime: String, checkTime: String, timeFormat: String = "HH:mm:ss"): Boolean
val calendar1 = Calendar.getInstance().apply
time = SimpleDateFormat(timeFormat, Locale.ENGLISH).parse(startTime)!!
add(Calendar.DATE, 1)
val calendar2 = Calendar.getInstance().apply
time = SimpleDateFormat(timeFormat, Locale.ENGLISH).parse(endTime)!!
add(Calendar.DATE, 1)
val calendar3 = Calendar.getInstance().apply
time = SimpleDateFormat(timeFormat, Locale.ENGLISH).parse(checkTime)!!
add(Calendar.DATE, 1)
if(calendar1.time > calendar2.time)
calendar2.add(Calendar.DATE, 2)
calendar3.add(Calendar.DATE, 2)
val x = calendar3.time
return (x.after(calendar1.time) && x.before(calendar2.time))
结果如下：
Log.d("TAG", "08:00, 22:00, 13:40: $isInBetween("08:00", "22:00", "13:40")") // true
Log.d("TAG", "22:00, 08:00, 13:40: $isInBetween("22:00", "08:00", "13:40")") // false
Log.d("TAG", "22:00, 08:00, 05:40: $isInBetween("22:00", "08:00", "05:40")") // true
Log.d("TAG", "22:00, 08:00, 10:40: $isInBetween("22:00", "08:00", "10:40")") // false
Log.d("TAG", "22:00, 22:00, 22:10: $isInBetween("22:00", "22:00", "22:10")") // false
【讨论】：
【参考方案28】：没有花哨的库的 Kotlin 代码，距离午夜计算只有几分钟。
private fun isInBetween(
startTime: String,
endTime: String,
currentTime: String
): Boolean
val startMinutesSinceMidnight = calculateMinutesSinceMidnight(startTime)
val endMinutesSinceMidnight = calculateMinutesSinceMidnight(endTime)
val currentMinutesSinceMidnight = calculateMinutesSinceMidnight(currentTime)
if (startMinutesSinceMidnight < endMinutesSinceMidnight)
return (currentMinutesSinceMidnight >= startMinutesSinceMidnight) && (currentMinutesSinceMidnight < endMinutesSinceMidnight)
else
return !((currentMinutesSinceMidnight >= endMinutesSinceMidnight) && (currentMinutesSinceMidnight < startMinutesSinceMidnight))
private fun calculateMinutesSinceMidnight(time_hh_mm: String): Int
val timeStrArray = time_hh_mm.split(":")
var minutes = timeStrArray[1].toInt()
minutes += 60 * timeStrArray[0].toInt()
return minutes
【讨论】：
【参考方案29】：这是我的解决方案，适用于 API 21+，我也包含在我的 Google Play 应用程序中：
@SuppressLint("SimpleDateFormat")
public static boolean currentTimeInBetween(long start, long finish) throws ParseException
Calendar startTime = Calendar.getInstance();
startTime.setTimeInMillis(start);
startTime.set(Calendar.MONTH, 3);
startTime.set(Calendar.DAY_OF_MONTH, 19);
Calendar finishTime = Calendar.getInstance();
finishTime.setTimeInMillis(finish);
finishTime.set(Calendar.MONTH, 3);
finishTime.set(Calendar.DAY_OF_MONTH, 19);
Calendar current = Calendar.getInstance();
current.set(Calendar.MONTH, 3);
current.set(Calendar.DAY_OF_MONTH, 19);
// Note: Above we have just set the date of startTime, finishTime and current to be exactly the same, although their times will be different. It's important that the date is identical.
// Lets say it's 14:00 now
Date currentTime = current.getTime();
if (startTime.after(finishTime))
startTime.add(Calendar.DATE, -1);
if (currentTime.after(startTime.getTime()) && currentTime.before(finishTime.getTime()))
// Example: startTime = 23:00, finishTime = 16:00
Log.d("Utils", "currentTimeInBetween: 1st scenario: startTime was yesterday\n"
+ "[startTime] " + startTime.getTime() + " >>>>> [currentTime] " + currentTime + " >>>>> [finishTime] " + finishTime.getTime());
return true;
if (currentTime.after(startTime.getTime()) && currentTime.before(finishTime.getTime()))
// Example: startTime = 10:00, finishTime = 16:00
Log.d("Utils", "currentTimeInBetween: 2nd scenario: startTime and finishTime are today\n"
+ "[startTime] " + startTime.getTime() + " >>>>> [currentTime] " + currentTime + " >>>>> [finishTime] " + finishTime.getTime());
return true;
startTime.add(Calendar.DATE, 1);
finishTime.add(Calendar.DATE, 1);
if (currentTime.after(startTime.getTime()) && currentTime.before(finishTime.getTime()))
// Example: startTime = 10:00, finishTime = 8:00
Log.d("Utils", "currentTimeInBetween: 3rd scenario: finishTime is tomorrow\n"
+ "[startTime] " + startTime.getTime() + " >>>>> [currentTime] " + currentTime + " >>>>> [finishTime] " + finishTime.getTime());
return true;
else
// Example: startTime = 10:00, finishTime = 12:00
Log.d("Utils", "currentTimeInBetween: current time is NOT between startTime & finishTime\n"
+ "[startTime] " + startTime.getTime() + " ||||| [currentTime] " + currentTime + " ||||| [finishTime] " + finishTime.getTime());
return false;
【讨论】：
【参考方案30】：对不起 sudo 代码..我在打电话。 ;)
between = (time < string2 && time > string1);
if (string1 > string2) between = !between;
如果它们是时间戳或字符串，则有效。只需更改变量名称以匹配
【讨论】：
以上是关于无论日期如何，检查给定时间是不是介于两次之间的主要内容，如果未能解决你的问题，请参考以下文章