【问题标题】: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

我想检查 time1time2 是否都在20:11:13 and 14:49:00 之间。

实际上,考虑到20:11:13 总是小于14:49:0001: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:0001: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 分钟”。我错过了什么?

标签: java android date calendar timespan


【解决方案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:1324:00:00 之间或00:00:0014: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.DateCalendarSimpleDateFormat

要了解更多信息,请参阅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 类?

【讨论】:

  • 这不适用于目标时间 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 的使用,但似乎并没有真正回答所问的问题。还要避免前缀零:它们适用于000204,但不适用于0809
                • 老兄,我很感谢您的反馈,但这就是我有时不喜欢 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 的其他平台,请使用它们,因为它们更优化且错误更少。

                        【讨论】:

                        • 我建议你不要使用CalendarSimpleDateFormat。这些类设计不佳且过时,尤其是后者出了名的麻烦。而是使用来自java.time, the modern Java date and time APILocalTimeDateTimeFormatter。此外,我发现您的代码甚至比 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;
                              

                              如果它们是时间戳或字符串,则有效。只需更改变量名称以匹配

                              【讨论】:

                                猜你喜欢
                                • 2015-01-23
                                • 1970-01-01
                                • 2020-02-26
                                • 2017-11-29
                                • 1970-01-01
                                • 1970-01-01
                                • 1970-01-01
                                • 2020-11-08
                                • 2021-08-23
                                相关资源
                                最近更新 更多