检查是否给定的时间处于两个时间之间不分日期的

Question

我有时间跨度：

字符串时间1 = 01:00:00

字符串时间2 = 05:00:00

我要检查，如果时间1和时间220:11:13 and 14:49:00之间既谎言。

其实，01:00:00大于20:11:13和小于14:49: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; 
    } 
} 

我知道这个代码不给出正确的结果，因为我比较字符串对象。

如何做到这一点，因为他们的时间跨度，但不字符串比较？

Answer 1

可以使用Calendar类，以便检查。

例如：

try { 
    String string1 = "20:11:13"; 
    Date time1 = new SimpleDateFormat("HH:mm:ss").parse(string1); 
    Calendar calendar1 = Calendar.getInstance(); 
    calendar1.setTime(time1); 

    String string2 = "14:49:00"; 
    Date time2 = new SimpleDateFormat("HH:mm:ss").parse(string2); 
    Calendar calendar2 = Calendar.getInstance(); 
    calendar2.setTime(time2); 
    calendar2.add(Calendar.DATE, 1); 

    String someRandomTime = "01:00:00"; 
    Date d = new SimpleDateFormat("HH:mm:ss").parse(someRandomTime); 
    Calendar calendar3 = Calendar.getInstance(); 
    calendar3.setTime(d); 
    calendar3.add(Calendar.DATE, 1); 

    Date x = calendar3.getTime(); 
    if (x.after(calendar1.getTime()) && x.before(calendar2.getTime())) { 
     //checkes whether the current time is between 14:49:00 and 20:11:13. 
     System.out.println(true); 
    } 
} catch (ParseException e) { 
    e.printStackTrace(); 
} 

Answer 2

对不起，电话上的须藤code..I'm。 ;）

=（时间< string2 & & time> string1）; if（string1> string2）介于=！之间;

如果他们是时间戳或字符串，它的工作原理。只是改变变量名匹配

Answer 3

与@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(); 
} 

Answer 4

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之间的时间间隔内，您需要解析当天的时间为 。从$时间

Answer 5

带冒号，$并从$字符串，转换成int，然后使用以下条件来检查时间是从和之间。例子是在PHP中，但不应该。

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

Answer 6

@kocko给出的答案仅在同一天工作。
如果启动时间“23:00:00”和结束“02:00:00” [次日]和当前时间是“01:30:00”那么结果将假...
我修改@ kocko的回答发挥最佳

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 
     java.util.Date inTime = new SimpleDateFormat("HH:mm:ss").parse(initialTime); 
     Calendar calendar1 = Calendar.getInstance(); 
     calendar1.setTime(inTime); 

     //Current Time 
     java.util.Date checkTime = new SimpleDateFormat("HH:mm:ss").parse(currentTime); 
     Calendar calendar3 = Calendar.getInstance(); 
     calendar3.setTime(checkTime); 

     //End Time 
     java.util.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]）

Answer 7

修改后的@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 

Answer 8

实际工作职能是为如下

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

Answer 9

在你的情况下，开始时间（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); 

Answer 10

声音对我说，你的问题是一个或情况......你要检查，如果时间1>二十点11分13秒或时间1 < 14:49:00。

从20:11:13开始，永远不会有超过你的范围的时间（14:49:00），反之亦然。想想看，就好像你正在检查一个时间不在正确排列的几个时间戳之间。

Answer 11

的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 
} 

Answer 12

以下方法检查“validateTime”是“开始时间” &“结束时间”与否之间，同时考虑可能性，“结束时间”可以是第二天。要正确使用它，请在“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; 
} 

Answer 13

TL;博士

20时11分13秒< 01:00:00 <十四时49分00秒

LocalTime target = LocalTime.parse("01:00:00") ; 
Boolean targetInZone = ( 
    target.isAfter(LocalTime.parse("20:11:13")) 
    && 
    target.isBefore(LocalTime.parse("14:49:00")) 
) ; 

java.time.LocalTime

化java。时间课程包括LocalTime代表只有一天的时间没有日期并没有时区。

所以我想要的是，20:11:13 < 01:00:00 < 14:49:00。

首先我们定义边界。您的输入字符串恰好符合标准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)) ; 

该测试可以更简单地表述为“AM和8 不之间下午3点”。然后，我们可以推广到任何一对LocalTime对象，其中我们测试之间如果开始之前24小时制停止，之间不是如果在停止后开始（如在此问题的情况下）。

更进一步，时间跨度通常与半开放式的方法来处理，其中最开始是包容而结局是独家。因此严格来说，“中间”比较将是“目标等于或晚于开始且目标在停止之前”，或者更简单地说，“在开始之前和停止之前是目标而不是”。

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。

Joda-Time项目现在在maintenance mode，建议迁移到java.time类。请致电Oracle Tutorial。并搜索堆栈溢出了很多例子和解释。规格是JSR 310。

从何处获取java.time类？

• Java SE 8和SE 9后来
  • 内置。
  • 带捆绑实现的标准Java API的一部分。
  • Java 9增加了一些次要功能和修复。在ThreeTen-Backport
• Java SE 6和SE 7
  • 大部分的java.time功能后移植到Java 6 & 7。
• Android
  • 的ThreeTenABP项目适应ThreeTen-反向移植（上述）为Android特异性。
  • 参见How to use ThreeTenABP…。

的ThreeTen-Extra项目与其他类扩展java.time。这个项目是未来可能增加java.time的一个试验场。您可以在这里找到一些有用的类，例如Interval,YearWeek,YearQuarter和more。

Answer 14

在一小段代码片段的下方，它被证实起始和结束时间或者未之间如果当前时间（可以是任何）存在：

 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 
     } 

Answer 15

使用本地时间将简单地忽略该日期值：

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

} 

Answer 16

在阅读了一些回复之后，我觉得写作太复杂了。试试我的代码

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

Answer 17

请不要往下投这个，这是工作，但需要一些改进。

long timeToSeconds(String time){ 
    long ret=0; 
    String[] ar = time.split("\\:"); 
    for(int i=0;i < ar.length ; i++){ 
     ret+= Long.valueOf(ar[i])* Math.pow(60,(2-i)); // (60^(2-i)); 
    } 
    return ret; 
} 
boolean isTimeBetween(String startTime, String endTime,String currentTime) { 
    long lCurrentTime = timeToSeconds(currentTime); 
    long lstartTime = timeToSeconds(startTime); 
    long lEndTime = timeToSeconds(endTime); 

    if(((lstartTime-lCurrentTime)*(lEndTime-lCurrentTime)*(lstartTime-lEndTime))>0){ 
     return true; 
    }else{ 
     return false; 
    } 
} 

//修改代码像这个 -

public void getTimeSpans(){ 
    boolean firstTime = false, secondTime = false; 

    if(isTimeBetween("20:11:13" ,"14:49:00",time1) 
    { 
     firstTime = true; 
    } 

    if(isTimeBetween("20:11:13" ,"14:49:00",time2) 
    { 
     secondTime = true; 
    } 
}