Java中查看当前时间是否落在当天的特定时间范围内

Question

我确信这已经在 1000 个不同的地方进行了 1000 次。问题是我想知道是否有更好/标准/更快的方法来检查当前“时间”是否在以 hh:mm:ss 格式给出的两个时间值之间。例如，我的大型业务逻辑不应在 18:00:00 和 18:30:00 之间运行。所以这就是我的想法：

 public static  boolean isCurrentTimeBetween(String starthhmmss, String endhhmmss) throws ParseException{
  DateFormat hhmmssFormat = new SimpleDateFormat("yyyyMMddhh:mm:ss");
  Date now = new Date();
  String yyyMMdd = hhmmssFormat.format(now).substring(0, 8);

  return(hhmmssFormat.parse(yyyMMdd+starthhmmss).before(now) &&
    hhmmssFormat.parse(yyyMMdd+endhhmmss).after(now));
 }

示例测试用例：

  String doNotRunBetween="18:00:00,18:30:00";//read from props file
  String[] hhmmss = downTime.split(",");
  if(isCurrentTimeBetween(hhmmss[0], hhmmss[1])){
   System.out.println("NOT OK TO RUN");
  }else{
   System.out.println("OK TO RUN");
  }

我正在寻找的是

• 性能
• 更好、外观
• 正确的

代码我不是在寻找

• 第三方库
• 异常处理辩论
• 变量命名约定
• 方法修饰符问题

Answer 1

这就是您需要做的全部，此方法与输入松散耦合且高度一致。

boolean isNowBetweenDateTime(final Date s, final Date e)
{
    final Date now = new Date();
    return now.after(s) && now.before(e);
}

如何获取开始和结束的 Date 对象与比较它们无关。通过传递 String 表示，您使事情变得比您需要的更加复杂。

这是获取开始日期和结束日期的更好方法，同样松散耦合且高度一致。

private Date dateFromHourMinSec(final String hhmmss)
{
    if (hhmmss.matches("^[0-2][0-9]:[0-5][0-9]:[0-5][0-9]$"))
    {
        final String[] hms = hhmmss.split(":");
        final GregorianCalendar gc = new GregorianCalendar();
        gc.set(Calendar.HOUR_OF_DAY, Integer.parseInt(hms[0]));
        gc.set(Calendar.MINUTE, Integer.parseInt(hms[1]));
        gc.set(Calendar.SECOND, Integer.parseInt(hms[2]));
        gc.set(Calendar.MILLISECOND, 0);
        return gc.getTime();
    }
    else
    {
        throw new IllegalArgumentException(hhmmss + " is not a valid time, expecting HH:MM:SS format");
    }
}

现在您可以进行两个命名良好的方法调用，这将是非常自记录的。

Answer 2

tl;dr

LocalTime now = 
    ZonedDateTime
        .now( ZoneId.of( "America/Montreal" ) )
        .toLocalTime() ;

Boolean isBetween = 
    ( ! now.isBefore( LocalTime.of( 18 , 0 ) )  // "not before" means "is equal to OR after".
    && 
    now.isBefore( LocalTime.of( 18 , 30 ) ) ;  // Half-Open, beginning is *inclusive* while ending is *exclusive*.
             

使用 java.time

您正在使用旧的日期时间类，这些类已被证明设计不佳、令人困惑且麻烦。它们现在是遗留，被 java.time 类取代。

LocalTime

不要仅传递表示时间值的字符串。我们现在有一个类型，即 LocalTime 类。

LocalTime start = LocalTime.of( 18 , 0 );
LocalTime stop = LocalTime.of( 18 , 30 );

将这些实例传递给您的实用程序方法。该方法不必执行任何解析，因此无需抛出解析异常。

public static  boolean isCurrentTimeBetween( LocalTime start , LocalTime stop ) {
…

ZonedDateTime

时区对于确定当前日期和时间至关重要。对于任何特定时刻，全球各地的日期都会因地区而异。例如，在法国巴黎午夜过后几分钟，又是新的一天“昨天”在魁北克蒙特利尔。

以大陆/地区格式指定正确的时区名称 ，例如 America/Montreal、非洲/卡萨布兰卡，或太平洋/奥克兰 。切勿使用 3-4 个字母的缩写，例如 EST 或 IST，因为它们不是真正的时区，不是标准化的，甚至不是唯一的（ ！）。

ZoneId z = ZoneId.of( "America/Montreal" );
ZonedDateTime zdt = ZonedDateTime.now( z );

为了比较现在的时间，我们可以简单地从 ZonedDateTime 中提取 LocalTime。但我们面临着异常问题，例如夏令时 (DST) 和政客重新定义时区。特定日期可能没有下午 6 点。此难题的解决方案取决于您的业务环境和业务规则。您可以忽略这个难题，直接询问当前时间是否在目标起止时间之间。或者，您可以将时区应用于一天中的起止时间，并让 ZonedDateTime 类根据需要进行调整。让我们看看这两种方法。

忽略异常

首先，忽略任何异常。简单地按字面意思询问当前时间是否在目标开始时间和停止时间之间。

我们可以从分区日期时间对象中提取一天中的时间对象。

LocalTime localTimeNow = zdt.toLocalTime(); // Extract a time-of-day from the zoned date-time object.

将其与我们一天中的启停时间进行比较。请注意，我们在这里使用半开放方法来定义时间跨度。在这种方法中，开头是包含，而结尾是排除。这种方法在约会工作中很常见，通常是明智的选择。

Boolean isNowOnOrAfterStart = ( ! localTimeNow.isBefore( start ) ) ;  // A briefer way of asking "is equal to OR is after" is "is not before". 
Boolean isNowBeforeStop = localTimeNow.isBefore( stop );
Boolean isNowInTargetZone = ( isNowOnOrAfterStart && isNowBeforeStop ); // Half-Open: beginning is inclusive while ending is exclusive.

考虑异常

接下来我们考虑任何异常。我们将一天中的开始和停止时间应用于同一时区内的当前日期。我们从分区日期时间对象中提取仅日期。

LocalDate localDateToday = zdt.toLocalDate();
ZonedDateTime zdtStart = ZonedDateTime.of( localDateToday , start , z );
ZonedDateTime zdtStop = ZonedDateTime.of( localDateToday , stop , z );

研究类文档以了解 ZonedDateTime.of 解决无效的时间值。没有完美的方法来解决不存在的时间值，因此您必须确定此类的方法是否满足您的业务规则。

ZonedDateTime.of

public static ZonedDateTime of(LocalDate 日期、LocalTime 时间、ZoneId 区域)

从本地日期和时间获取 ZonedDateTime 的实例。
这将创建一个与输入的本地日期和时间尽可能匹配的分区日期时间。时区规则（例如夏令时）意味着并非每个本地日期时间都对指定区域有效，因此本地日期时间可能会进行调整。

首先将本地日期时间与本地日期时间结合起来形成本地日期时间。然后，本地日期时间被解析为时间线上的单个时刻。这是通过找到区域 ID 规则定义的本地日期时间与 UTC/格林威治的有效偏移量来实现的。

在大多数情况下，本地日期时间只有一个有效的偏移量。在重叠的情况下，当时钟被调回时，有两个有效的偏移。此方法使用通常对应于“夏天”的较早偏移量。

在有间隙的情况下，当时钟向前跳跃时，没有有效的偏移。相反，本地日期时间会根据间隙的长度调整为较晚的时间。对于典型的一小时夏令时更改，本地日期时间将移至一小时后，通常对应于“夏季”的偏移量中。

应用与我们上面看到的相同的比较逻辑。

Boolean isNowOnOrAfterStart = ( ! zdt.isBefore( zdtStart ) ) ;  // A briefer way of asking "is equal to OR is after" is "is not before". 
Boolean isNowBeforeStop = zdt.isBefore( zdtStop );
Boolean isNowInTargetZone = ( isNowOnOrAfterStart && isNowBeforeStop ); // Half-Open: beginning is inclusive while ending is exclusive.

进行比较的另一种方法是使用 ThreeTen-Extra 项目中方便的 Interval 类。该类需要使用 Instant 对象，您可以从 ZonedDateTime 对象中提取这些对象。 即时 类代表 UTC 中时间轴上的时刻，分辨率为 纳秒（最多九 (9) 位小数）。

Interval interval = Interval.of( zdtStart.toInstant() , zdtStop.toInstant() );
Boolean isNowInTargetZone = interval.contains( zdt.toInstant() );

---

关于 java.time

java.time 框架内置于 Java 8 及更高版本中。这些类取代了麻烦的旧遗留日期时间类，例如java.util.Date, 日历, & ; SimpleDateFormat 。

Joda-Time 项目，现已在 维护模式，建议迁移到 java.time 类。

要了解更多信息，请参阅 Oracle 教程。并在 Stack Overflow 上搜索许多示例和解释。规范为 JSR 310。

从哪里获取 java.time 类？

• Java SE 8 和 SE 9 及更高
• 版本内置。
• 具有捆绑实现的标准 Java API 的一部分。
• Java 9 添加了一些小功能和修复。
• Java SE 6 和 SE 7
• 许多 java.time 功能向后移植到 Java 6 和 Java 6。 7 ThreeTen-Backport。
• Android
• ThreeTenABP 项目采用 ThreeTen-Backport （上面提到的）专门针对Android。
• 请参阅如何使用 ThreeTenABP...。

ThreeTen-Extra 项目通过附加类扩展了 java.time。该项目是 java.time 未来可能添加的内容的试验场。您可能会在这里找到一些有用的类，例如 间隔，YearWeek，<代码>YearQuarter，以及更多 。

Answer 3

正如 Kevin 所指出的，Fuzzy Lollipop 的正则表达式不会获取 14:00 到 19:00 之间的时间。

要获得完整的 24 小时时钟，您可以使用以下命令：

if (hhmmss.matches("^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$"))
{
    // Do stuff here
}

Answer 4

下面的类是我刚刚根据其他答案的一些代码创建的。它封装了“时间段”的行为，与特定日期无关。我们的系统使用此类来检查当前时间是否在我们指定的维护窗口之一内。即 05:00:00 - 07:00:00

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
*
* @author Adam Yocum
*/
public class ExclusionTimePeriod {
    private String timeStart;
    private String timeEnd;

    /**
    * @return the timeStart
    */
    public String getTimeStart() {
        return timeStart;
    }

    /**
    * @param timeStart the timeStart to set
    */
    public void setTimeStart(String timeStart) {
        if (timeStart.matches("^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$"))
        {
            this.timeStart = timeStart;
        }
        else
        {
            throw new IllegalArgumentException(timeStart + " is not a valid time, expecting HH:MM:SS format");
        }

    }

    /**
    * @return the timeEnd
    */
    public String getTimeEnd() {
        return timeEnd;
    }

    /**
    * @param timeEnd the timeEnd to set
    */
    public void setTimeEnd(String timeEnd) {
        if (timeEnd.matches("^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$"))
        {
            this.timeEnd = timeEnd;
        }
        else
        {
            throw new IllegalArgumentException(timeEnd + " is not a valid time, expecting HH:MM:SS format");
        }
    }

    private Date toDate(String hhmmss){
        final String[] hms = hhmmss.split(":");
        final GregorianCalendar gc = new GregorianCalendar();
        gc.set(Calendar.HOUR_OF_DAY, Integer.parseInt(hms[0]));
        gc.set(Calendar.MINUTE, Integer.parseInt(hms[1]));
        gc.set(Calendar.SECOND, Integer.parseInt(hms[2]));
        gc.set(Calendar.MILLISECOND, 0);
        Date date = gc.getTime();
        return date;
    }

    public boolean isNowInPeriod()
    {
        final Date now = new Date();
        return now.after(toDate(getTimeStart())) && now.before(toDate(getTimeEnd()));
    }

    public static void main(String[] args){

        //Test All possible hours
        for(int hour=0;hour<=23;hour++){

            String hourStr = "";
            if(hour<=9){
                hourStr = "0"+hour;
            }else{
                hourStr = ""+hour;
            }

            for(int min=0;min<60;min++){
                String minStr = "";
                if(min<=9){
                    minStr = "0"+min;
                }else{
                    minStr = ""+min;
                }

                for(int sec=0;sec<60;sec++){
                    String secStr = "";
                    if(sec<=9){
                        secStr = "0"+sec;
                    }else{
                        secStr = ""+sec;
                    }

                    String hhmmss = hourStr+":"+minStr+":"+secStr;

                    ExclusionTimePeriod period = new ExclusionTimePeriod();
                    period.setTimeStart(hhmmss);
                    period.setTimeEnd(hhmmss);

                    System.out.println(hhmmss+" Ok");
                }
            }
        }


        //Test isInPeriod functionality
        ExclusionTimePeriod isInTest = new ExclusionTimePeriod();
        isInTest.setTimeStart("10:00:00");
        isInTest.setTimeEnd("10:43:00");

        System.out.println((new Date())+" is between "+isInTest.getTimeStart()+" and "+isInTest.getTimeEnd()+" = "+isInTest.isNowInPeriod());

    }
}

Answer 5

午夜问题

其他答案没有提到它 - 并且OP也没有问 - 但你应该真正考虑间隔跨越午夜。

时间很困难。我故意留下了代码的“长”版本，并且没有缩写逻辑条件，以尽可能清楚地说明是什么和为什么。

/**
 * Takes into consideration that the interval may span accross midnight
 *
 * @param clock to make unit testing easier, just replace for Clock.systemUTC() in your code 
 * @param start the interval start
 * @param end the interval end
 * @return true if "now" is inside the specified interval
 */
static boolean isNowBetweenLocalTime(Clock clock, final LocalTime start, final LocalTime end) {
    LocalTime now = LocalTime.now(clock);

    // if interval crosses midnight
    if (end.isBefore(start)) {
        if (now.isAfter(start) && now.isAfter(end)) {
            return true;
        }
        if (now.isBefore(start) && now.isBefore(end)) {
            return true;
        }
        return false;
    }

    // if interval does not cross midnight
    if (end.isAfter(start)) {
        if (now.isAfter(start) && now.isBefore(end)) {
            return true;
        }
        return false;
    }

    return false; // interval is 0 so start and end always outside interval
}

冗长并不总是错误的。这个方法将被隐藏在一个实用程序类中，两年后你会感谢自己理解它的作用！

Answer 6

dateFromHourMinSec 方法如所写的那样存在缺陷。它不允许第二位数字大于 3 的任何时间，例如 18:00:00。如果将其更改为允许 [0-2][0-9]，它将允许 29:00:00 等时间。
有解决办法吗？